Repository: phoenixframework/phoenix Branch: main Commit: eca672ec4bdc Files: 454 Total size: 3.1 MB Directory structure: gitextract_fy0ivb69/ ├── .formatter.exs ├── .github/ │ ├── ISSUE_TEMPLATE/ │ │ ├── bug_report.md │ │ └── config.yml │ ├── dependabot.yml │ └── workflows/ │ ├── assets.yml │ ├── ci.yml │ └── npm-publish.yml ├── .gitignore ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE.md ├── README.md ├── RELEASE.md ├── SECURITY.md ├── assets/ │ ├── js/ │ │ └── phoenix/ │ │ ├── ajax.js │ │ ├── channel.js │ │ ├── constants.js │ │ ├── index.js │ │ ├── longpoll.js │ │ ├── presence.js │ │ ├── push.js │ │ ├── serializer.js │ │ ├── socket.js │ │ ├── timer.js │ │ └── utils.js │ └── test/ │ ├── channel_test.js │ ├── longpoll_test.js │ ├── presence_test.js │ ├── serializer.js │ ├── serializer_test.js │ ├── socket_http_test.js │ └── socket_test.js ├── babel.config.json ├── config/ │ └── config.exs ├── eslint.config.mjs ├── guides/ │ ├── asset_management.md │ ├── authn_authz/ │ │ ├── api_authentication.md │ │ ├── authn_authz.md │ │ ├── mix_phx_gen_auth.md │ │ └── scopes.md │ ├── cheatsheets/ │ │ └── router.cheatmd │ ├── components.md │ ├── controllers.md │ ├── data_modelling/ │ │ ├── contexts.md │ │ ├── cross_context_boundaries.md │ │ ├── faq.md │ │ ├── in_context_relationships.md │ │ ├── more_examples.md │ │ └── your_first_context.md │ ├── deployment/ │ │ ├── deployment.md │ │ ├── fly.md │ │ ├── gigalixir.md │ │ ├── heroku.md │ │ └── releases.md │ ├── directory_structure.md │ ├── ecto.md │ ├── howto/ │ │ ├── custom_error_pages.md │ │ ├── file_uploads.md │ │ ├── swapping_databases.md │ │ ├── using_ssl.md │ │ └── writing_a_channels_client.md │ ├── introduction/ │ │ ├── community.md │ │ ├── installation.md │ │ ├── overview.md │ │ ├── packages_glossary.md │ │ └── up_and_running.md │ ├── json_and_apis.md │ ├── live_view.md │ ├── plug.md │ ├── real_time/ │ │ ├── channels.md │ │ └── presence.md │ ├── request_lifecycle.md │ ├── routing.md │ ├── security.md │ ├── telemetry.md │ └── testing/ │ ├── testing.md │ ├── testing_channels.md │ ├── testing_contexts.md │ └── testing_controllers.md ├── installer/ │ ├── .gitignore │ ├── README.md │ ├── lib/ │ │ ├── mix/ │ │ │ └── tasks/ │ │ │ ├── local.phx.ex │ │ │ ├── phx.new.ecto.ex │ │ │ ├── phx.new.ex │ │ │ └── phx.new.web.ex │ │ └── phx_new/ │ │ ├── ecto.ex │ │ ├── generator.ex │ │ ├── mailer.ex │ │ ├── project.ex │ │ ├── single.ex │ │ ├── umbrella.ex │ │ └── web.ex │ ├── mix.exs │ ├── recreate_default_css.exs │ ├── templates/ │ │ ├── phx_assets/ │ │ │ ├── app.css.eex │ │ │ ├── app.js.eex │ │ │ ├── daisyui-theme.js.eex │ │ │ ├── daisyui.js.eex │ │ │ ├── heroicons.js.eex │ │ │ ├── logo.svg.eex │ │ │ ├── topbar.js.eex │ │ │ └── tsconfig.json.eex │ │ ├── phx_ecto/ │ │ │ ├── data_case.ex.eex │ │ │ ├── formatter.exs.eex │ │ │ ├── repo.ex.eex │ │ │ └── seeds.exs.eex │ │ ├── phx_gettext/ │ │ │ ├── en/ │ │ │ │ └── LC_MESSAGES/ │ │ │ │ └── errors.po.eex │ │ │ ├── errors.pot.eex │ │ │ └── gettext.ex.eex │ │ ├── phx_mailer/ │ │ │ └── lib/ │ │ │ └── app_name/ │ │ │ └── mailer.ex.eex │ │ ├── phx_single/ │ │ │ ├── README.md.eex │ │ │ ├── config/ │ │ │ │ ├── config.exs.eex │ │ │ │ ├── dev.exs.eex │ │ │ │ ├── prod.exs.eex │ │ │ │ ├── runtime.exs.eex │ │ │ │ └── test.exs.eex │ │ │ ├── formatter.exs.eex │ │ │ ├── gitignore.eex │ │ │ ├── lib/ │ │ │ │ ├── app_name/ │ │ │ │ │ └── application.ex.eex │ │ │ │ ├── app_name.ex.eex │ │ │ │ └── app_name_web.ex.eex │ │ │ ├── mix.exs.eex │ │ │ └── test/ │ │ │ └── test_helper.exs.eex │ │ ├── phx_static/ │ │ │ ├── app.css │ │ │ ├── app.js │ │ │ ├── default.css │ │ │ └── robots.txt │ │ ├── phx_test/ │ │ │ ├── controllers/ │ │ │ │ ├── error_html_test.exs.eex │ │ │ │ ├── error_json_test.exs.eex │ │ │ │ └── page_controller_test.exs.eex │ │ │ └── support/ │ │ │ └── conn_case.ex.eex │ │ ├── phx_umbrella/ │ │ │ ├── README.md.eex │ │ │ ├── apps/ │ │ │ │ ├── app_name/ │ │ │ │ │ ├── README.md.eex │ │ │ │ │ ├── config/ │ │ │ │ │ │ └── config.exs.eex │ │ │ │ │ ├── formatter.exs.eex │ │ │ │ │ ├── gitignore.eex │ │ │ │ │ ├── lib/ │ │ │ │ │ │ ├── app_name/ │ │ │ │ │ │ │ └── application.ex.eex │ │ │ │ │ │ └── app_name.ex.eex │ │ │ │ │ ├── mix.exs.eex │ │ │ │ │ └── test/ │ │ │ │ │ └── test_helper.exs.eex │ │ │ │ └── app_name_web/ │ │ │ │ ├── README.md.eex │ │ │ │ ├── config/ │ │ │ │ │ ├── config.exs.eex │ │ │ │ │ ├── dev.exs.eex │ │ │ │ │ ├── prod.exs.eex │ │ │ │ │ ├── runtime.exs.eex │ │ │ │ │ └── test.exs.eex │ │ │ │ ├── formatter.exs.eex │ │ │ │ ├── gitignore.eex │ │ │ │ ├── lib/ │ │ │ │ │ ├── app_name/ │ │ │ │ │ │ └── application.ex.eex │ │ │ │ │ └── app_name.ex.eex │ │ │ │ ├── mix.exs.eex │ │ │ │ └── test/ │ │ │ │ └── test_helper.exs.eex │ │ │ ├── config/ │ │ │ │ ├── config.exs.eex │ │ │ │ ├── dev.exs.eex │ │ │ │ ├── extra_config.exs.eex │ │ │ │ ├── prod.exs.eex │ │ │ │ ├── runtime.exs.eex │ │ │ │ └── test.exs.eex │ │ │ ├── formatter.exs.eex │ │ │ ├── gitignore.eex │ │ │ └── mix.exs.eex │ │ ├── phx_web/ │ │ │ ├── components/ │ │ │ │ ├── core_components.ex.eex │ │ │ │ ├── layouts/ │ │ │ │ │ └── root.html.heex.eex │ │ │ │ └── layouts.ex.eex │ │ │ ├── controllers/ │ │ │ │ ├── error_html.ex.eex │ │ │ │ ├── error_json.ex.eex │ │ │ │ ├── page_controller.ex.eex │ │ │ │ ├── page_html/ │ │ │ │ │ └── home.html.heex.eex │ │ │ │ └── page_html.ex.eex │ │ │ ├── endpoint.ex.eex │ │ │ ├── router.ex.eex │ │ │ └── telemetry.ex.eex │ │ └── usage-rules/ │ │ ├── assets.md │ │ ├── phoenix.md │ │ └── project.md │ └── test/ │ ├── mix_helper.exs │ ├── phx_new_ecto_test.exs │ ├── phx_new_test.exs │ ├── phx_new_umbrella_test.exs │ ├── phx_new_web_test.exs │ └── test_helper.exs ├── integration_test/ │ ├── README.md │ ├── config/ │ │ └── config.exs │ ├── docker-compose.yml │ ├── docker.sh │ ├── mix.exs │ ├── test/ │ │ ├── code_generation/ │ │ │ ├── app_with_defaults_test.exs │ │ │ ├── app_with_mssql_adapter_test.exs │ │ │ ├── app_with_mysql_adapter_test.exs │ │ │ ├── app_with_no_options_test.exs │ │ │ ├── app_with_scopes_test.exs │ │ │ ├── app_with_sqlite3_adapter_test.exs │ │ │ └── umbrella_app_with_defaults_test.exs │ │ ├── support/ │ │ │ └── code_generator_case.ex │ │ └── test_helper.exs │ └── test.sh ├── jest.config.js ├── lib/ │ ├── mix/ │ │ ├── phoenix/ │ │ │ ├── context.ex │ │ │ ├── schema.ex │ │ │ └── scope.ex │ │ ├── phoenix.ex │ │ └── tasks/ │ │ ├── compile.phoenix.ex │ │ ├── phx.digest.clean.ex │ │ ├── phx.digest.ex │ │ ├── phx.ex │ │ ├── phx.gen.auth/ │ │ │ ├── hashing_library.ex │ │ │ ├── injector.ex │ │ │ └── migration.ex │ │ ├── phx.gen.auth.ex │ │ ├── phx.gen.cert.ex │ │ ├── phx.gen.channel.ex │ │ ├── phx.gen.context.ex │ │ ├── phx.gen.embedded.ex │ │ ├── phx.gen.ex │ │ ├── phx.gen.html.ex │ │ ├── phx.gen.json.ex │ │ ├── phx.gen.live.ex │ │ ├── phx.gen.notifier.ex │ │ ├── phx.gen.presence.ex │ │ ├── phx.gen.release.ex │ │ ├── phx.gen.schema.ex │ │ ├── phx.gen.secret.ex │ │ ├── phx.gen.socket.ex │ │ ├── phx.routes.ex │ │ └── phx.server.ex │ ├── phoenix/ │ │ ├── channel/ │ │ │ └── server.ex │ │ ├── channel.ex │ │ ├── code_reloader/ │ │ │ ├── mix_listener.ex │ │ │ ├── proxy.ex │ │ │ └── server.ex │ │ ├── code_reloader.ex │ │ ├── config.ex │ │ ├── controller/ │ │ │ └── pipeline.ex │ │ ├── controller.ex │ │ ├── debug.ex │ │ ├── digester/ │ │ │ ├── compressor.ex │ │ │ └── gzip.ex │ │ ├── digester.ex │ │ ├── endpoint/ │ │ │ ├── cowboy2_adapter.ex │ │ │ ├── render_errors.ex │ │ │ ├── supervisor.ex │ │ │ ├── sync_code_reload_plug.ex │ │ │ └── watcher.ex │ │ ├── endpoint.ex │ │ ├── exceptions.ex │ │ ├── flash.ex │ │ ├── logger.ex │ │ ├── naming.ex │ │ ├── param.ex │ │ ├── presence.ex │ │ ├── router/ │ │ │ ├── console_formatter.ex │ │ │ ├── helpers.ex │ │ │ ├── resource.ex │ │ │ ├── route.ex │ │ │ └── scope.ex │ │ ├── router.ex │ │ ├── socket/ │ │ │ ├── message.ex │ │ │ ├── pool_supervisor.ex │ │ │ ├── serializer.ex │ │ │ ├── serializers/ │ │ │ │ ├── v1_json_serializer.ex │ │ │ │ └── v2_json_serializer.ex │ │ │ └── transport.ex │ │ ├── socket.ex │ │ ├── test/ │ │ │ ├── channel_test.ex │ │ │ └── conn_test.ex │ │ ├── token.ex │ │ ├── transports/ │ │ │ ├── long_poll.ex │ │ │ ├── long_poll_server.ex │ │ │ └── websocket.ex │ │ └── verified_routes.ex │ └── phoenix.ex ├── mix.exs ├── package.json ├── priv/ │ ├── static/ │ │ ├── phoenix.cjs.js │ │ ├── phoenix.js │ │ └── phoenix.mjs │ └── templates/ │ ├── phx.gen.auth/ │ │ ├── AGENTS.md.eex │ │ ├── auth.ex.eex │ │ ├── auth_test.exs.eex │ │ ├── confirmation_live.ex.eex │ │ ├── confirmation_live_test.exs.eex │ │ ├── conn_case.exs.eex │ │ ├── context_fixtures_functions.ex.eex │ │ ├── context_functions.ex.eex │ │ ├── login_live.ex.eex │ │ ├── login_live_test.exs.eex │ │ ├── migration.ex.eex │ │ ├── notifier.ex.eex │ │ ├── registration_controller.ex.eex │ │ ├── registration_controller_test.exs.eex │ │ ├── registration_html.ex.eex │ │ ├── registration_live.ex.eex │ │ ├── registration_live_test.exs.eex │ │ ├── registration_new.html.heex.eex │ │ ├── routes.ex.eex │ │ ├── schema.ex.eex │ │ ├── schema_token.ex.eex │ │ ├── scope.ex.eex │ │ ├── session_confirm.html.heex.eex │ │ ├── session_controller.ex.eex │ │ ├── session_controller_test.exs.eex │ │ ├── session_html.ex.eex │ │ ├── session_new.html.heex.eex │ │ ├── settings_controller.ex.eex │ │ ├── settings_controller_test.exs.eex │ │ ├── settings_edit.html.heex.eex │ │ ├── settings_html.ex.eex │ │ ├── settings_live.ex.eex │ │ ├── settings_live_test.exs.eex │ │ └── test_cases.exs.eex │ ├── phx.gen.channel/ │ │ ├── channel.ex.eex │ │ ├── channel_case.ex.eex │ │ └── channel_test.exs.eex │ ├── phx.gen.context/ │ │ ├── access_no_schema.ex.eex │ │ ├── access_no_schema_scope.ex.eex │ │ ├── context.ex.eex │ │ ├── context_test.exs.eex │ │ ├── fixtures.ex.eex │ │ ├── fixtures_module.ex.eex │ │ ├── schema_access.ex.eex │ │ ├── schema_access_scope.ex.eex │ │ ├── test_cases.exs.eex │ │ └── test_cases_scope.exs.eex │ ├── phx.gen.embedded/ │ │ └── embedded_schema.ex.eex │ ├── phx.gen.html/ │ │ ├── controller.ex.eex │ │ ├── controller_test.exs.eex │ │ ├── edit.html.heex.eex │ │ ├── html.ex.eex │ │ ├── index.html.heex.eex │ │ ├── new.html.heex.eex │ │ ├── resource_form.html.heex.eex │ │ └── show.html.heex.eex │ ├── phx.gen.json/ │ │ ├── changeset_json.ex.eex │ │ ├── controller.ex.eex │ │ ├── controller_test.exs.eex │ │ ├── fallback_controller.ex.eex │ │ └── json.ex.eex │ ├── phx.gen.live/ │ │ ├── form.ex.eex │ │ ├── index.ex.eex │ │ ├── live_test.exs.eex │ │ └── show.ex.eex │ ├── phx.gen.notifier/ │ │ ├── notifier.ex.eex │ │ └── notifier_test.exs.eex │ ├── phx.gen.presence/ │ │ └── presence.ex.eex │ ├── phx.gen.release/ │ │ ├── Dockerfile.eex │ │ ├── dockerignore.eex │ │ ├── rel/ │ │ │ ├── migrate.bat.eex │ │ │ ├── migrate.sh.eex │ │ │ ├── server.bat.eex │ │ │ └── server.sh.eex │ │ └── release.ex.eex │ ├── phx.gen.schema/ │ │ ├── migration.exs.eex │ │ └── schema.ex.eex │ └── phx.gen.socket/ │ ├── socket.ex.eex │ └── socket.js.eex ├── test/ │ ├── fixtures/ │ │ ├── digest/ │ │ │ ├── cleaner/ │ │ │ │ ├── cache_manifest.json │ │ │ │ └── latest_not_most_recent_cache_manifest.json │ │ │ ├── compile/ │ │ │ │ ├── cache_manifest.json │ │ │ │ └── cache_manifest_upgrade.json │ │ │ └── priv/ │ │ │ ├── output/ │ │ │ │ ├── foo-288ea8c7954498e65663c817382eeac4.css │ │ │ │ └── foo-d978852bea6530fcd197b5445ed008fd.css │ │ │ └── static/ │ │ │ ├── app.js │ │ │ ├── css/ │ │ │ │ └── app.css │ │ │ ├── foo.css │ │ │ ├── manifest.json │ │ │ └── precompressed.js.br │ │ ├── hello.txt │ │ ├── ssl/ │ │ │ ├── cert.pem │ │ │ └── key.pem │ │ ├── templates/ │ │ │ ├── custom.foo │ │ │ ├── layout/ │ │ │ │ ├── app.html.eex │ │ │ │ └── root.html.eex │ │ │ ├── no_trim.text.eex │ │ │ ├── path.html.eex │ │ │ ├── safe.html.eex │ │ │ ├── show.html.eex │ │ │ ├── trim.html.eex │ │ │ └── user/ │ │ │ ├── index.html.eex │ │ │ ├── profiles/ │ │ │ │ └── admin.html.eex │ │ │ ├── render_template.html.eex │ │ │ └── show.json.exs │ │ └── views.exs │ ├── mix/ │ │ ├── phoenix_test.exs │ │ └── tasks/ │ │ ├── phx.digest.clean_test.exs │ │ ├── phx.digest_test.exs │ │ ├── phx.gen.auth/ │ │ │ └── injector_test.exs │ │ ├── phx.gen.auth_test.exs │ │ ├── phx.gen.cert_test.exs │ │ ├── phx.gen.channel_test.exs │ │ ├── phx.gen.context_test.exs │ │ ├── phx.gen.embedded_test.exs │ │ ├── phx.gen.html_test.exs │ │ ├── phx.gen.json_test.exs │ │ ├── phx.gen.live_test.exs │ │ ├── phx.gen.notifier_test.exs │ │ ├── phx.gen.presence_test.exs │ │ ├── phx.gen.release_test.exs │ │ ├── phx.gen.schema_test.exs │ │ ├── phx.gen.secret_test.exs │ │ ├── phx.gen.socket_test.exs │ │ ├── phx.routes_test.exs │ │ └── phx_test.exs │ ├── phoenix/ │ │ ├── channel_test.exs │ │ ├── code_reloader_test.exs │ │ ├── config_test.exs │ │ ├── controller/ │ │ │ ├── controller_test.exs │ │ │ ├── flash_test.exs │ │ │ ├── pipeline_test.exs │ │ │ └── render_test.exs │ │ ├── debug_test.exs │ │ ├── digester/ │ │ │ └── gzip_test.exs │ │ ├── digester_test.exs │ │ ├── endpoint/ │ │ │ ├── endpoint_test.exs │ │ │ ├── render_errors_test.exs │ │ │ ├── supervisor_test.exs │ │ │ └── watcher_test.exs │ │ ├── integration/ │ │ │ ├── endpoint_test.exs │ │ │ ├── long_poll_channels_test.exs │ │ │ ├── long_poll_socket_test.exs │ │ │ ├── websocket_channels_test.exs │ │ │ └── websocket_socket_test.exs │ │ ├── logger_test.exs │ │ ├── naming_test.exs │ │ ├── param_test.exs │ │ ├── presence_test.exs │ │ ├── router/ │ │ │ ├── console_formatter_test.exs │ │ │ ├── forward_test.exs │ │ │ ├── helpers_test.exs │ │ │ ├── pipeline_test.exs │ │ │ ├── resource_test.exs │ │ │ ├── resources_test.exs │ │ │ ├── route_test.exs │ │ │ ├── routing_test.exs │ │ │ └── scope_test.exs │ │ ├── socket/ │ │ │ ├── message_test.exs │ │ │ ├── socket_test.exs │ │ │ ├── transport_test.exs │ │ │ ├── v1_json_serializer_test.exs │ │ │ └── v2_json_serializer_test.exs │ │ ├── test/ │ │ │ ├── channel_test.exs │ │ │ └── conn_test.exs │ │ ├── token_test.exs │ │ └── verified_routes_test.exs │ ├── support/ │ │ ├── endpoint_helper.exs │ │ ├── http_client.exs │ │ ├── router_helper.exs │ │ └── websocket_client.exs │ └── test_helper.exs └── usage-rules/ ├── ecto.md ├── elixir.md ├── html.md ├── liveview.md └── phoenix.md ================================================ FILE CONTENTS ================================================ ================================================ FILE: .formatter.exs ================================================ locals_without_parens = [ # Phoenix.Channel intercept: 1, # Phoenix.Router connect: 3, connect: 4, delete: 3, delete: 4, forward: 2, forward: 3, forward: 4, get: 3, get: 4, head: 3, head: 4, match: 4, match: 5, options: 3, options: 4, patch: 3, patch: 4, pipeline: 2, pipe_through: 1, post: 3, post: 4, put: 3, put: 4, resources: 2, resources: 3, resources: 4, trace: 4, # Phoenix.Controller action_fallback: 1, # Phoenix.Endpoint plug: 1, plug: 2, socket: 2, socket: 3, # Phoenix.Socket channel: 2, channel: 3, # Phoenix.ChannelTest assert_broadcast: 2, assert_broadcast: 3, assert_push: 2, assert_push: 3, assert_reply: 2, assert_reply: 3, assert_reply: 4, refute_broadcast: 2, refute_broadcast: 3, refute_push: 2, refute_push: 3, refute_reply: 2, refute_reply: 3, refute_reply: 4, # Phoenix.ConnTest assert_error_sent: 2, # Phoenix.Live{Dashboard,View} attr: 2, attr: 3, embed_templates: 1, embed_templates: 2, live: 2, live: 3, live: 4, live_dashboard: 1, live_dashboard: 2, on_mount: 1, slot: 1, slot: 2, slot: 3, # Phoenix.LiveViewTest assert_patch: 1, assert_patch: 2, assert_patch: 3, assert_patched: 2, assert_push_event: 3, assert_push_event: 4, assert_redirect: 1, assert_redirect: 2, assert_redirect: 3, assert_redirected: 2, assert_reply: 2, assert_reply: 3, refute_redirected: 1, refute_redirected: 2, refute_patched: 1, refute_patched: 2, refute_push_event: 3, refute_push_event: 4 ] [ locals_without_parens: locals_without_parens, export: [locals_without_parens: locals_without_parens] ] ================================================ FILE: .github/ISSUE_TEMPLATE/bug_report.md ================================================ --- name: Bug report about: Create a report to help us improve title: '' labels: '' assignees: '' --- ### Environment * Elixir version (elixir -v): * Phoenix version (mix deps): * Operating system: ### Actual behavior ### Expected behavior ================================================ FILE: .github/ISSUE_TEMPLATE/config.yml ================================================ --- blank_issues_enabled: true contact_links: - name: Ask questions, support, and general discussions url: https://elixirforum.com/c/phoenix-forum about: Ask questions, provide support, and more on Elixir Forum - name: Propose new features url: https://elixirforum.com/c/phoenix-forum about: Propose new features on Elixir Forum ================================================ FILE: .github/dependabot.yml ================================================ version: 2 updates: # Maintain dependencies for GitHub Actions - package-ecosystem: "github-actions" directory: "/" schedule: interval: "monthly" # Maintain dependencies for NPM - package-ecosystem: "npm" directory: "/" schedule: interval: "monthly" groups: minor-and-patch: applies-to: version-updates update-types: - "minor" - "patch" ================================================ FILE: .github/workflows/assets.yml ================================================ name: Assets on: push: branches: - main - "v*.*" permissions: contents: read jobs: build: runs-on: ubuntu-24.04 env: elixir: 1.18.3 otp: 27.2 permissions: contents: write # for stefanzweifel/git-auto-commit-action to push code in repo steps: - name: Checkout uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Set up Elixir uses: erlef/setup-beam@3580539ceec3dc05b0ed51e9e10b08eb7a7c2bb4 # v1.21.0 with: elixir-version: ${{ env.elixir }} otp-version: ${{ env.otp }} - name: Restore deps and _build cache uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 with: path: | deps _build key: ${{ runner.os }}-mix-${{ env.elixir }}-${{ env.otp }}-${{ hashFiles('**/mix.lock') }}-dev restore-keys: | ${{ runner.os }}-mix-${{ env.elixir }}-${{ env.otp }}- - name: Install Dependencies run: mix deps.get --only dev - name: Set up Node.js 20.x uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0 with: node-version: 20.x - name: Restore npm cache uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 with: path: ~/.npm key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} restore-keys: | ${{ runner.os }}-node- - name: Install npm dependencies run: npm ci - name: Build assets run: mix assets.build - name: Push updated assets id: push_assets uses: stefanzweifel/git-auto-commit-action@04702edda442b2e678b25b537cec683a1493fcb9 # v7.1.0 with: commit_message: Update assets file_pattern: priv/static ================================================ FILE: .github/workflows/ci.yml ================================================ name: CI on: [push, pull_request] permissions: contents: read jobs: mix_test: name: mix test (OTP ${{matrix.otp}} | Elixir ${{matrix.elixir}}) env: MIX_ENV: test PHX_CI: true strategy: matrix: include: - elixir: "1.15.8" otp: "25.3.2.9" - elixir: "1.18.4" otp: "27.3" - elixir: "1.19.5" otp: "28.3.3" lint: true installer: true runs-on: ubuntu-24.04 steps: - name: Checkout uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Set up Elixir uses: erlef/setup-beam@3580539ceec3dc05b0ed51e9e10b08eb7a7c2bb4 # v1.21.0 with: elixir-version: ${{ matrix.elixir }} otp-version: ${{ matrix.otp }} - name: Restore deps and _build cache uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 with: path: | deps _build key: deps-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-${{ hashFiles('**/mix.lock') }} restore-keys: | deps-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }} - name: Install dependencies run: mix deps.get --only test - name: Remove compiled application files run: mix clean - name: Compile & lint dependencies run: mix compile --warnings-as-errors if: ${{ matrix.lint }} - name: Run tests run: mix test - name: Run installer test run: | cd installer mix deps.get mix test if: ${{ matrix.installer }} npm_test: name: npm test runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Restore deps and _build cache uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 with: path: | deps _build key: deps-${{ runner.os }}-npm-${{ hashFiles('**/mix.lock') }} restore-keys: | deps-${{ runner.os }}-npm - name: Set up Node.js 20.x uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0 with: node-version: 20.x - name: Restore npm cache uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 with: path: ~/.npm key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} restore-keys: | ${{ runner.os }}-node- - name: npm install and test run: | cd assets npm install npm test integration-test-elixir: runs-on: ubuntu-latest strategy: matrix: include: # look for correct alpine image here: https://hub.docker.com/r/hexpm/elixir/tags - elixir: "1.15.8" otp: "25.3.2.9" suffix: "alpine-3.20.3" - elixir: "1.19.5" otp: "28.3.3" suffix: "alpine-3.20.9" container: image: hexpm/elixir:${{ matrix.elixir }}-erlang-${{ matrix.otp }}-${{ matrix.suffix }} env: ELIXIR_ASSERT_TIMEOUT: 10000 PHX_CI: true services: postgres: image: postgres ports: - 5432:5432 env: POSTGRES_PASSWORD: postgres mysql: image: mysql ports: - 3306:3306 env: MYSQL_ALLOW_EMPTY_PASSWORD: "yes" mssql: image: mcr.microsoft.com/mssql/server:2019-latest env: ACCEPT_EULA: Y SA_PASSWORD: some!Password ports: - 1433:1433 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Run test script run: ./integration_test/test.sh ================================================ FILE: .github/workflows/npm-publish.yml ================================================ # https://docs.npmjs.com/trusted-publishers name: NPM Publish on: push: tags: - "v*" permissions: id-token: write # Required for OIDC contents: read jobs: publish: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 with: node-version: "24" registry-url: "https://registry.npmjs.org" # Ensure npm 11.5.1 or later is installed - name: Update npm run: npm install -g npm@latest - name: Determine npm tag id: npm-tag run: | TAG=${GITHUB_REF#refs/tags/} # Update this condition when bumping the major version! if [[ $TAG == v1.7.* ]]; then echo "tag=old-version" >> $GITHUB_OUTPUT elif [[ $TAG == *-rc* ]]; then echo "tag=rc" >> $GITHUB_OUTPUT else echo "tag=latest" >> $GITHUB_OUTPUT fi - name: Publish to npm run: npm publish --tag ${{ steps.npm-tag.outputs.tag }} ================================================ FILE: .gitignore ================================================ /_build/ /deps/ /doc/ /node_modules/ /tmp/ /cover/ /assets/node_modules/ /installer/_build/ /installer/assets/ /installer/deps/ /installer/doc/ /installer/phx_new-*.ez /installer/tmp/ /integration_test/_build/ /integration_test/deps/ erl_crash.dump phoenix-*.ez .DS_Store /priv/templates/phx.gen.live/core_components.ex.eex ================================================ FILE: CHANGELOG.md ================================================ # Changelog for v1.8 This release requires Erlang/OTP 25+. ## Streamlined generators * Extend tailwindcss support in new apps with [daisyUI](https://daisyui.com/) for light/dark/system mode support for entire app, including core components * Simplify layout handling for new apps. Now there is only a single `root.html.heex` which wraps the render pipeline. Other dynamic layouts, like `app.html.heex` are called as needed within templates as regular function components * Simplify core components and live generators to more closely match basic `phx.gen.html` crud. This serves as a better base for seasoned devs to start with, and lessens the amount of code newcomers need to get up to speed with on the basics * Introduce magic links (passwordless auth) and "sudo mode" to `mix phx.gen.auth` while simplifying the generated structure * Introduce scopes to Phoenix generators, designed to make secure data access the *default*, not something you remember (or forget) to do later ## `put_secure_browser_headers` `put_secure_browser_headers` has been updated to the latest security practices. In particular, it sets the `content-security-policy` header to `"base-uri 'self'; frame-ancestors 'self';"` if none is set, restricting embedding of your application and the use of `` element to same origin respectively. If you expect your application to be embedded by third-parties, you want to consult the documentation. The headers `x-download-options` and `x-frame-options` are no longer set as they have been deprecated by standards. ## Deprecations This release introduces deprecation warnings for several features that have been soft-deprecated in the past. * `use Phoenix.Controller` must now specify the `:formats` option, which may be set to an empty list if the formats are not known upfront * The `:namespace` and `:put_default_views` options on `use Phoenix.Controller` are deprecated and emit a warning on use * Specifying layouts without modules, such as `put_layout(conn, :print)` or `put_layout(conn, html: :print)` is deprecated * The `:trailing_slash` option in `Phoenix.Router` has been deprecated in favor of using `Phoenix.VerifiedRoutes`. The overall usage of helpers will be deprecated in the future ## Potential breaking changes * The `config` variable is no longer available in `Phoenix.Endpoint`. In the past, it was possible to read your endpoint configuration at compile-time via an injected variable named `config`, which is no longer supported. Use `Application.compile_env/3` instead, which is tracked by the Elixir compiler and lead to a better developer experience. This may also lead to errors on application boot if you were previously incorrectly setting compile time config at runtime. ## 1.8.5 (2026-03-05) ### JavaScript Client Bug Fixes - Fix socket connecting on visibility change when never established ### Enhancements - Fix warnings on Elixir 1.20 ## 1.8.4 (2026-02-23) ### JavaScript Client Bug Fixes - Fix bug reconnecting connections when close was gracefully initiated by server - Fix LongPoll transport name in sessionStorage and logs ### Enhancements - Adds guards support in `assert_push`, `assert_broadcast`, and `assert_reply` - Enable purging in Phoenix code server for Elixir 1.20 ## 1.8.3 (2025-12-08) ### Enhancements - Add top-level phoenix config: `sort_verified_routes_query_params` to enable sorting query params in verified routes during tests ### Bug fixes - Fix endpoint port config in an umbrella application. ([#6549](https://github.com/phoenixframework/phoenix/pull/6549)) - Drop incoming channel messages with stale join refs ## 1.8.2 (2025-11-26) ### Bug fixes - [phoenix.js] fix issue where LongPoll can cause "unmatched topic" errors (observed on iOS only) ([#6538](https://github.com/phoenixframework/phoenix/pull/6538)) - [phx.gen.live] fix tests when schema and table names are equal ([#6477](https://github.com/phoenixframework/phoenix/pull/6477)) - [Verified Routes] do not add path prefixes for static routes - [Phoenix.Endpoint] fix LongPoll being active by default since 1.8.0 ([#6487](https://github.com/phoenixframework/phoenix/pull/6487)) ### Enhancements - [phoenix.js] socket now stops reconnection attempts while the page is hidden ([#6534](https://github.com/phoenixframework/phoenix/pull/6534)) - [phx.new] (re-)add `<.input field={@form[:foo]} type="hidden" />` support in core components - [phx.new] set `force_ssl` in `prod.exs` by default ([#6435](https://github.com/phoenixframework/phoenix/pull/6435)) - [phx.new] change `--docker` base image to debian trixie ([#6521](https://github.com/phoenixframework/phoenix/pull/6521)) - [Phoenix.Socket.assign/2] allow passing a function as second argument `assign(socket, fn _existing_assigns -> %{this_gets: "merged"} end)` ([#6530](https://github.com/phoenixframework/phoenix/pull/6530)) - [Phoenix.Controller.assign/2] allow passing a function as second argument ([#6542](https://github.com/phoenixframework/phoenix/pull/6542)) - [Phoenix.Controller.assign/2] support keyword lists and maps as second argument similar to LiveView ([#6513](https://github.com/phoenixframework/phoenix/pull/6513)) - [Presence] support custom dispatcher for `presence_diff` broadcast ([#6500](https://github.com/phoenixframework/phoenix/pull/6500)) - [AGENTS.md] add short test guidelines to usage rules ## 1.8.1 (2025-08-28) ### Bug fixes - [phx.new] Fix AGENTS.md failing to include CSS and JavaScript sections ## 1.8.0 (2025-08-05) ### Bug fixes - [phx.new] Don't include node_modules override in generated `tsconfig.json` ### Enhancements - [phx.gen.live|html|json] - Make context argument optional. Defaults to the plural name. - [phx.new] Add `mix precommit` alias - [phx.new] Add `AGENTS.md` generation compatible with [`usage_rules`](https://hexdocs.pm/usage_rules/) - [phx.new] Add `usage_rules` folder to installer, allowing to sync generic Phoenix rules into new projects - [phx.new] Use LiveView 1.1 release in generated code - [phx.new] Ensure theme selector and flash closing works without LiveView ## 1.8.0-rc.4 (2025-07-14) ### Bug Fixes - Fix phx.gen.presence PubSub server name for umbrella apps - Fix `phx.gen.live` subscribing to pubsub in disconnected mounts ### Enhancements - [phx.new] Initialize initial git repo when git is installed - [phx.new] Opt-in to HEEx `:debug_tags_location` in development - [phx.gen.live|html|json|context] Make context name optional and inflect based on schema when missing - [phx.gen.*] Use new Ecto 3.13 `Repo.transact/2` in generators - [phx.gen.auth] Warn when using `phx.gen.auth` without esbuild as features assume `phoenix_html.js` in bundle - Add `security.md` guide for security best practices - [phoenix.js] - Add fetch() support to LongPoll when XMLHTTPRequest is not available - Optimize parameter scrubbing by precompiling patterns ## 1.8.0-rc.3 (2025-05-07) ### Enhancements - [phx.gen.auth] Allow configuring the scope's assign key in phx.gen.auth - [phx.new] Do not override theme in root layout if explicitly set ## 1.8.0-rc.2 (2025-04-29) ### Bug Fixes - [phx.gen.live] Only subscribe to pubsub if connected - [phx.gen.auth] Remove unused current_password field - [phx.gen.auth] Use context_app for scopes to fix generated scopes in umbrella apps ## 1.8.0-rc.1 (2025-04-16) ### Enhancements - [phx.new] Support PORT in dev - [phx.gen.auth] Replace `utc_now/0 + truncate/1` with `utc_now/1` - [phx.gen.auth] Make dev mailbox link more obvious ### Bug Fixes - [phx.new] Fix Tailwind custom variants for loading classes (#6194) - [phx.new] Fix heroicons path for umbrella apps - [phx.gen.auth] Fix missing index for scoped resources (#6186) - [phx.gen.live] Fix crash when an open :show page gets a PubSub broadcast for items (#6197) ## 1.8.0-rc.0 (2025-04-01) 🚀 - First release candidate! ## v1.7 The CHANGELOG for v1.7 releases can be found in the [v1.7 branch](https://github.com/phoenixframework/phoenix/blob/v1.7/CHANGELOG.md). ================================================ FILE: CODE_OF_CONDUCT.md ================================================ # Contributor Code of Conduct As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities. We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality. Examples of unacceptable behavior by participants include: * The use of sexualized language or imagery * Personal attacks * Trolling or insulting/derogatory comments * Public or private harassment * Publishing other's private information, such as physical or electronic addresses, without explicit permission * Other unethical or unprofessional conduct. Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team. This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 1.2.0, available at [https://www.contributor-covenant.org/version/1/2/0/code-of-conduct/](https://www.contributor-covenant.org/version/1/2/0/code-of-conduct/) ================================================ FILE: CONTRIBUTING.md ================================================ # Contributing to Phoenix Please take a moment to review this document in order to make the contribution process easy and effective for everyone involved! Also make sure you read our [Code of Conduct](CODE_OF_CONDUCT.md) that outlines our commitment towards an open and welcoming environment. ## Using the issue tracker Use the issues tracker for: * [Bug reports](#bug-reports) * [Submitting pull requests](#pull-requests) For requesting help and discussing new features: * [The Phoenix subforum on the Elixir Forum](https://elixirforum.com/c/phoenix-forum) * **[#elixir](irc://irc.libera.chat/elixir)** on [Libera](https://libera.chat/) IRC We do our best to keep the issue tracker tidy and organized, making it useful for everyone. For example, we classify open issues per perceived difficulty, making it easier for developers to [contribute to Phoenix](#pull-requests). ## Bug reports A bug is either a _demonstrable problem_ that is caused by the code in the repository, or indicates missing, unclear, or misleading documentation. Good bug reports are extremely helpful - thank you! Guidelines for bug reports: 1. **Use the GitHub issue search** — check if the issue has already been reported. 2. **Check if the issue has been fixed** — try to reproduce it using the `main` branch in the repository. 3. **Isolate and report the problem** — ideally create a reduced test case. Please try to be as detailed as possible in your report. Include information about your Operating System, as well as your Erlang, Elixir and Phoenix versions. Please provide steps to reproduce the issue as well as the outcome you were expecting! All these details will help developers to fix any potential bugs. Example: > Short and descriptive example bug report title > > A summary of the issue and the environment in which it occurs. If suitable, > include the steps required to reproduce the bug. > > 1. This is the first step > 2. This is the second step > 3. Further steps, etc. > > `` - a link to the reduced test case (e.g. a GitHub Gist) > > Any other information you want to share that is relevant to the issue being > reported. This might include the lines of code that you have identified as > causing the bug, and potential solutions (and your opinions on their > merits). ## Feature requests Feature requests are welcome and should be discussed on the [Phoenix subforum](https://elixirforum.com/c/phoenix-forum). But take a moment to find out whether your idea fits with the scope and aims of the project. It's up to *you* to make a strong case to convince the community of the merits of this feature. Please provide as much detail and context as possible. ## Contributing Documentation Code documentation (`@doc`, `@moduledoc`, `@typedoc`) has a special convention: the first paragraph is considered to be a short summary. For functions, macros, and callbacks say what it will do. For example write something like: ```elixir @doc """ Marks the given value as HTML safe. """ def safe({:safe, value}), do: {:safe, value} ``` For modules, protocols, and types say what it is. For example write something like: ```elixir defmodule Phoenix.HTML do @moduledoc """ Conveniences for working HTML strings and templates. ... """ ``` Keep in mind that the first paragraph might show up in a summary somewhere, long texts in the first paragraph create very ugly summaries. As a rule of thumb anything longer than 80 characters is too long. Try to keep unnecessary details out of the first paragraph, it's only there to give a user a quick idea of what the documented "thing" does/is. The rest of the documentation string can contain the details, for example when a value and when `nil` is returned. If possible include examples, preferably in a form that works with doctests. This makes it easy to test the examples so that they don't go stale and examples are often a great help in explaining what a function does. ## Pull requests Good pull requests - patches, improvements, new features - are a fantastic help. They should remain focused in scope and avoid containing unrelated commits. **IMPORTANT**: By submitting a patch, you agree that your work will be licensed under the license used by the project. If you have any large pull request in mind (e.g. implementing features, refactoring code, etc), **please ask first** otherwise you risk spending a lot of time working on something that the project's developers might not want to merge into the project. Please adhere to the coding conventions in the project (indentation, accurate comments, etc.) and don't forget to add your own tests and documentation. When working with git, we recommend the following process in order to craft an excellent pull request: 1. [Fork](https://help.github.com/articles/fork-a-repo/) the project, clone your fork, and configure the remotes: ```bash # Clone your fork of the repo into the current directory git clone https://github.com//phoenix # Navigate to the newly cloned directory cd phoenix # Assign the original repo to a remote called "upstream" git remote add upstream https://github.com/phoenixframework/phoenix ``` 2. If you cloned a while ago, get the latest changes from upstream, and update your fork: ```bash git checkout main git pull upstream main git push ``` 3. Create a new topic branch (off of `main`) to contain your feature, change, or fix. **IMPORTANT**: Making changes in `main` is discouraged. You should always keep your local `main` in sync with upstream `main` and make your changes in topic branches. ```bash git checkout -b ``` 4. Commit your changes in logical chunks. Keep your commit messages organized, with a short description in the first line and more detailed information on the following lines. Feel free to use Git's [interactive rebase](https://help.github.com/articles/about-git-rebase/) feature to tidy up your commits before making them public. 5. Make sure all the tests are still passing. ```bash mix test ``` 6. Push your topic branch up to your fork: ```bash git push origin ``` 7. [Open a Pull Request](https://help.github.com/articles/about-pull-requests/) with a clear title and description. 8. If you haven't updated your pull request for a while, you should consider rebasing on main and resolving any conflicts. **IMPORTANT**: _Never ever_ merge upstream `main` into your branches. You should always `git rebase` on `main` to bring your changes up to date when necessary. ```bash git checkout main git pull upstream main git checkout git rebase main ``` Thank you for your contributions! ## Guides These Guides aim to be inclusive. We use "we" and "our" instead of "you" and "your" to foster this sense of inclusion. Ideally there is something for everybody in each guide, from beginner to expert. This is hard, maybe impossible. When we need to compromise, we do so on behalf of beginning users because expert users have more tools at their disposal to help themselves. The general pattern we use for presenting information is to first introduce a small, discrete topic, then write a small amount of code to demonstrate the concept, then verify that the code worked. In this way, we build from small, easily digestible concepts into more complex ones. The shorter this cycle is, as long as the information is still clear and complete, the better. For formatting the guides: - We use the `elixir` code fence for all module code. - We use the `iex` for IEx sessions. - We use the `console` code fence for shell commands. - We use the `html` code fence for html templates, even if there is elixir code in the template. - We use backticks for filenames and directory paths. - We use backticks for module names, function names, and variable names. - Documentation line length should hard wrapped at around 100 characters if possible. ================================================ FILE: LICENSE.md ================================================ # MIT License Copyright (c) 2014 Chris McCord Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ Phoenix logo > Peace of mind from prototype to production. [![Build Status](https://github.com/phoenixframework/phoenix/workflows/CI/badge.svg)](https://github.com/phoenixframework/phoenix/actions/workflows/ci.yml) [![Hex.pm](https://img.shields.io/hexpm/v/phoenix.svg)](https://hex.pm/packages/phoenix) [![Documentation](https://img.shields.io/badge/documentation-gray)](https://hexdocs.pm/phoenix) ## Getting started See the official site at . Install the latest version of Phoenix by following the instructions at . ## Documentation API documentation is available at . Phoenix.js documentation is available at . ## Contributing We appreciate any contribution to Phoenix. Check our [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) and [CONTRIBUTING.md](CONTRIBUTING.md) guides for more information. We usually keep a list of features and bugs in the [issue tracker][4]. ### Generating a Phoenix project from unreleased versions You can create a new project using the latest Phoenix source installer (the `phx.new` Mix task) with the following steps: 1. Remove any previously installed `phx_new` archives so that Mix will pick up the local source code. This can be done with `mix archive.uninstall phx_new` or by simply deleting the file, which is usually in `~/.mix/archives/`. 2. Copy this repo via `git clone https://github.com/phoenixframework/phoenix` or by downloading it 3. Run the `phx.new` Mix task from within the `installer` directory, for example: ```bash cd phoenix/installer mix phx.new dev_app --dev ``` The `--dev` flag will configure your new project's `:phoenix` dep as a relative path dependency, pointing to your local Phoenix checkout: ```elixir defp deps do [{:phoenix, path: "../..", override: true}, ``` To create projects outside of the `installer/` directory, add the latest archive to your machine by following the instructions in [installer/README.md](https://github.com/phoenixframework/phoenix/blob/main/installer/README.md) ### Building from source To build the documentation: ```bash npm install MIX_ENV=docs mix docs ``` To build Phoenix: ```bash mix deps.get mix compile ``` To build the Phoenix installer: ```bash mix deps.get mix compile mix archive.build ``` To build Phoenix.js: ```bash cd assets npm install ``` ## Important links * [#elixir][1] on [Libera][2] IRC * [elixir-lang Slack channel][3] * [Issues tracker][4] * [Phoenix Forum (questions and proposals)][5] * Visit Phoenix's sponsor, DockYard, for expert [Phoenix Consulting](https://dockyard.com/phoenix-consulting) [1]: https://web.libera.chat/?channels=#elixir [2]: https://libera.chat/ [3]: https://elixir-lang.slack.com/ [4]: https://github.com/phoenixframework/phoenix/issues [5]: https://elixirforum.com/c/phoenix-forum ## Copyright and License Copyright (c) 2014, Chris McCord. Phoenix source code is licensed under the [MIT License](LICENSE.md). ================================================ FILE: RELEASE.md ================================================ # Release Instructions 1. Check related deps for required version bumps and compatibility (`phoenix_ecto`, `phoenix_html`) 2. Bump version in related files below 3. Bump external dependency version in related external files below 4. Run tests: - `mix test` in the root folder - `mix test` in the `installer/` folder 5. Commit, push code 6. Publish `phx_new` and `phoenix` packages and docs after pruning any extraneous uncommitted files 7. Test installer by generating a new app, running `mix deps.get`, and compiling 8. Publish to `npm` with `npm publish` 9. Update Elixir and Erlang/OTP versions on new.phoenixframework.org 10. Start -dev version in related files below ## Files with version * `CHANGELOG` * `mix.exs` * `installer/mix.exs` * `package.json` * `assets/package.json` ## Files with external dependency versions * `priv/templates/phx.gen.release/Docker.eex` (debian) * `priv/templates/phx.gen.release/Docker.eex` (esbuild) ================================================ FILE: SECURITY.md ================================================ # Security Policy ## Supported versions Phoenix applies bug fixes only to the latest minor branch. Security patches are available for the last 4 minor branches: Phoenix version | Support :-------------- | :----------------------------- 1.7 | Bug fixes and security patches 1.6 | Security patches only 1.5 | Security patches only 1.4 | Security patches only ## Announcements [Security advisories will be published on GitHub](https://github.com/phoenixframework/phoenix/security). ## Reporting a vulnerability [Please disclose security vulnerabilities privately via GitHub](https://github.com/phoenixframework/phoenix/security). ================================================ FILE: assets/js/phoenix/ajax.js ================================================ import { global, XHR_STATES } from "./constants" export default class Ajax { static request(method, endPoint, headers, body, timeout, ontimeout, callback){ if(global.XDomainRequest){ let req = new global.XDomainRequest() // IE8, IE9 return this.xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback) } else if(global.XMLHttpRequest){ let req = new global.XMLHttpRequest() // IE7+, Firefox, Chrome, Opera, Safari return this.xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback) } else if(global.fetch && global.AbortController){ // Fetch with AbortController for modern browsers return this.fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback) } else { throw new Error("No suitable XMLHttpRequest implementation found") } } static fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback){ let options = { method, headers, body, } let controller = null if(timeout){ controller = new AbortController() const _timeoutId = setTimeout(() => controller.abort(), timeout) options.signal = controller.signal } global.fetch(endPoint, options) .then(response => response.text()) .then(data => this.parseJSON(data)) .then(data => callback && callback(data)) .catch(err => { if(err.name === "AbortError" && ontimeout){ ontimeout() } else { callback && callback(null) } }) return controller } static xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback){ req.timeout = timeout req.open(method, endPoint) req.onload = () => { let response = this.parseJSON(req.responseText) callback && callback(response) } if(ontimeout){ req.ontimeout = ontimeout } // Work around bug in IE9 that requires an attached onprogress handler req.onprogress = () => { } req.send(body) return req } static xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback){ req.open(method, endPoint, true) req.timeout = timeout for(let [key, value] of Object.entries(headers)){ req.setRequestHeader(key, value) } req.onerror = () => callback && callback(null) req.onreadystatechange = () => { if(req.readyState === XHR_STATES.complete && callback){ let response = this.parseJSON(req.responseText) callback(response) } } if(ontimeout){ req.ontimeout = ontimeout } req.send(body) return req } static parseJSON(resp){ if(!resp || resp === ""){ return null } try { return JSON.parse(resp) } catch { console && console.log("failed to parse JSON response", resp) return null } } static serialize(obj, parentKey){ let queryStr = [] for(var key in obj){ if(!Object.prototype.hasOwnProperty.call(obj, key)){ continue } let paramKey = parentKey ? `${parentKey}[${key}]` : key let paramVal = obj[key] if(typeof paramVal === "object"){ queryStr.push(this.serialize(paramVal, paramKey)) } else { queryStr.push(encodeURIComponent(paramKey) + "=" + encodeURIComponent(paramVal)) } } return queryStr.join("&") } static appendParams(url, params){ if(Object.keys(params).length === 0){ return url } let prefix = url.match(/\?/) ? "&" : "?" return `${url}${prefix}${this.serialize(params)}` } } ================================================ FILE: assets/js/phoenix/channel.js ================================================ import {closure} from "./utils" import { CHANNEL_EVENTS, CHANNEL_STATES, } from "./constants" import Push from "./push" import Timer from "./timer" /** * * @param {string} topic * @param {(Object|function)} params * @param {Socket} socket */ export default class Channel { constructor(topic, params, socket){ this.state = CHANNEL_STATES.closed this.topic = topic this.params = closure(params || {}) this.socket = socket this.bindings = [] this.bindingRef = 0 this.timeout = this.socket.timeout this.joinedOnce = false this.joinPush = new Push(this, CHANNEL_EVENTS.join, this.params, this.timeout) this.pushBuffer = [] this.stateChangeRefs = [] this.rejoinTimer = new Timer(() => { if(this.socket.isConnected()){ this.rejoin() } }, this.socket.rejoinAfterMs) this.stateChangeRefs.push(this.socket.onError(() => this.rejoinTimer.reset())) this.stateChangeRefs.push(this.socket.onOpen(() => { this.rejoinTimer.reset() if(this.isErrored()){ this.rejoin() } }) ) this.joinPush.receive("ok", () => { this.state = CHANNEL_STATES.joined this.rejoinTimer.reset() this.pushBuffer.forEach(pushEvent => pushEvent.send()) this.pushBuffer = [] }) this.joinPush.receive("error", () => { this.state = CHANNEL_STATES.errored if(this.socket.isConnected()){ this.rejoinTimer.scheduleTimeout() } }) this.onClose(() => { this.rejoinTimer.reset() if(this.socket.hasLogger()) this.socket.log("channel", `close ${this.topic} ${this.joinRef()}`) this.state = CHANNEL_STATES.closed this.socket.remove(this) }) this.onError(reason => { if(this.socket.hasLogger()) this.socket.log("channel", `error ${this.topic}`, reason) if(this.isJoining()){ this.joinPush.reset() } this.state = CHANNEL_STATES.errored if(this.socket.isConnected()){ this.rejoinTimer.scheduleTimeout() } }) this.joinPush.receive("timeout", () => { if(this.socket.hasLogger()) this.socket.log("channel", `timeout ${this.topic} (${this.joinRef()})`, this.joinPush.timeout) let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), this.timeout) leavePush.send() this.state = CHANNEL_STATES.errored this.joinPush.reset() if(this.socket.isConnected()){ this.rejoinTimer.scheduleTimeout() } }) this.on(CHANNEL_EVENTS.reply, (payload, ref) => { this.trigger(this.replyEventName(ref), payload) }) } /** * Join the channel * @param {integer} timeout * @returns {Push} */ join(timeout = this.timeout){ if(this.joinedOnce){ throw new Error("tried to join multiple times. 'join' can only be called a single time per channel instance") } else { this.timeout = timeout this.joinedOnce = true this.rejoin() return this.joinPush } } /** * Hook into channel close * @param {Function} callback */ onClose(callback){ this.on(CHANNEL_EVENTS.close, callback) } /** * Hook into channel errors * @param {Function} callback */ onError(callback){ return this.on(CHANNEL_EVENTS.error, reason => callback(reason)) } /** * Subscribes on channel events * * Subscription returns a ref counter, which can be used later to * unsubscribe the exact event listener * * @example * const ref1 = channel.on("event", do_stuff) * const ref2 = channel.on("event", do_other_stuff) * channel.off("event", ref1) * // Since unsubscription, do_stuff won't fire, * // while do_other_stuff will keep firing on the "event" * * @param {string} event * @param {Function} callback * @returns {integer} ref */ on(event, callback){ let ref = this.bindingRef++ this.bindings.push({event, ref, callback}) return ref } /** * Unsubscribes off of channel events * * Use the ref returned from a channel.on() to unsubscribe one * handler, or pass nothing for the ref to unsubscribe all * handlers for the given event. * * @example * // Unsubscribe the do_stuff handler * const ref1 = channel.on("event", do_stuff) * channel.off("event", ref1) * * // Unsubscribe all handlers from event * channel.off("event") * * @param {string} event * @param {integer} ref */ off(event, ref){ this.bindings = this.bindings.filter((bind) => { return !(bind.event === event && (typeof ref === "undefined" || ref === bind.ref)) }) } /** * @private */ canPush(){ return this.socket.isConnected() && this.isJoined() } /** * Sends a message `event` to phoenix with the payload `payload`. * Phoenix receives this in the `handle_in(event, payload, socket)` * function. if phoenix replies or it times out (default 10000ms), * then optionally the reply can be received. * * @example * channel.push("event") * .receive("ok", payload => console.log("phoenix replied:", payload)) * .receive("error", err => console.log("phoenix errored", err)) * .receive("timeout", () => console.log("timed out pushing")) * @param {string} event * @param {Object} payload * @param {number} [timeout] * @returns {Push} */ push(event, payload, timeout = this.timeout){ payload = payload || {} if(!this.joinedOnce){ throw new Error(`tried to push '${event}' to '${this.topic}' before joining. Use channel.join() before pushing events`) } let pushEvent = new Push(this, event, function (){ return payload }, timeout) if(this.canPush()){ pushEvent.send() } else { pushEvent.startTimeout() this.pushBuffer.push(pushEvent) } return pushEvent } /** Leaves the channel * * Unsubscribes from server events, and * instructs channel to terminate on server * * Triggers onClose() hooks * * To receive leave acknowledgements, use the `receive` * hook to bind to the server ack, ie: * * @example * channel.leave().receive("ok", () => alert("left!") ) * * @param {integer} timeout * @returns {Push} */ leave(timeout = this.timeout){ this.rejoinTimer.reset() this.joinPush.cancelTimeout() this.state = CHANNEL_STATES.leaving let onClose = () => { if(this.socket.hasLogger()) this.socket.log("channel", `leave ${this.topic}`) this.trigger(CHANNEL_EVENTS.close, "leave") } let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), timeout) leavePush.receive("ok", () => onClose()) .receive("timeout", () => onClose()) leavePush.send() if(!this.canPush()){ leavePush.trigger("ok", {}) } return leavePush } /** * Overridable message hook * * Receives all events for specialized message handling * before dispatching to the channel callbacks. * * Must return the payload, modified or unmodified * @param {string} event * @param {Object} payload * @param {integer} ref * @returns {Object} */ onMessage(_event, payload, _ref){ return payload } /** * @private */ isMember(topic, event, payload, joinRef){ if(this.topic !== topic){ return false } if(joinRef && joinRef !== this.joinRef()){ if(this.socket.hasLogger()) this.socket.log("channel", "dropping outdated message", {topic, event, payload, joinRef}) return false } else { return true } } /** * @private */ joinRef(){ return this.joinPush.ref } /** * @private */ rejoin(timeout = this.timeout){ if(this.isLeaving()){ return } this.socket.leaveOpenTopic(this.topic) this.state = CHANNEL_STATES.joining this.joinPush.resend(timeout) } /** * @private */ trigger(event, payload, ref, joinRef){ let handledPayload = this.onMessage(event, payload, ref, joinRef) if(payload && !handledPayload){ throw new Error("channel onMessage callbacks must return the payload, modified or unmodified") } let eventBindings = this.bindings.filter(bind => bind.event === event) for(let i = 0; i < eventBindings.length; i++){ let bind = eventBindings[i] bind.callback(handledPayload, ref, joinRef || this.joinRef()) } } /** * @private */ replyEventName(ref){ return `chan_reply_${ref}` } /** * @private */ isClosed(){ return this.state === CHANNEL_STATES.closed } /** * @private */ isErrored(){ return this.state === CHANNEL_STATES.errored } /** * @private */ isJoined(){ return this.state === CHANNEL_STATES.joined } /** * @private */ isJoining(){ return this.state === CHANNEL_STATES.joining } /** * @private */ isLeaving(){ return this.state === CHANNEL_STATES.leaving } } ================================================ FILE: assets/js/phoenix/constants.js ================================================ export const globalSelf = typeof self !== "undefined" ? self : null export const phxWindow = typeof window !== "undefined" ? window : null export const global = globalSelf || phxWindow || globalThis export const DEFAULT_VSN = "2.0.0" export const SOCKET_STATES = {connecting: 0, open: 1, closing: 2, closed: 3} export const DEFAULT_TIMEOUT = 10000 export const WS_CLOSE_NORMAL = 1000 export const CHANNEL_STATES = { closed: "closed", errored: "errored", joined: "joined", joining: "joining", leaving: "leaving", } export const CHANNEL_EVENTS = { close: "phx_close", error: "phx_error", join: "phx_join", reply: "phx_reply", leave: "phx_leave" } export const TRANSPORTS = { longpoll: "longpoll", websocket: "websocket" } export const XHR_STATES = { complete: 4 } export const AUTH_TOKEN_PREFIX = "base64url.bearer.phx." ================================================ FILE: assets/js/phoenix/index.js ================================================ /** * Phoenix Channels JavaScript client * * ## Socket Connection * * A single connection is established to the server and * channels are multiplexed over the connection. * Connect to the server using the `Socket` class: * * ```javascript * let socket = new Socket("/socket", {params: {userToken: "123"}}) * socket.connect() * ``` * * The `Socket` constructor takes the mount point of the socket, * the authentication params, as well as options that can be found in * the Socket docs, such as configuring the `LongPoll` transport, and * heartbeat. * * ## Channels * * Channels are isolated, concurrent processes on the server that * subscribe to topics and broker events between the client and server. * To join a channel, you must provide the topic, and channel params for * authorization. Here's an example chat room example where `"new_msg"` * events are listened for, messages are pushed to the server, and * the channel is joined with ok/error/timeout matches: * * ``` * let channel = socket.channel("room:123", {token: roomToken}) * channel.on("new_msg", msg => console.log("Got message", msg) ) * $input.onEnter( e => { * channel.push("new_msg", {body: e.target.val}, 10000) * .receive("ok", (msg) => console.log("created message", msg) ) * .receive("error", (reasons) => console.log("create failed", reasons) ) * .receive("timeout", () => console.log("Networking issue...") ) * }) * * channel.join() * .receive("ok", ({messages}) => console.log("catching up", messages) ) * .receive("error", ({reason}) => console.log("failed join", reason) ) * .receive("timeout", () => console.log("Networking issue. Still waiting...")) *``` * * ## Joining * * Creating a channel with `socket.channel(topic, params)`, binds the params to * `channel.params`, which are sent up on `channel.join()`. * Subsequent rejoins will send up the modified params for * updating authorization params, or passing up last_message_id information. * Successful joins receive an "ok" status, while unsuccessful joins * receive "error". * * With the default serializers and WebSocket transport, JSON text frames are * used for pushing a JSON object literal. If an `ArrayBuffer` instance is provided, * binary encoding will be used and the message will be sent with the binary * opcode. * * *Note*: binary messages are only supported on the WebSocket transport. * * ## Duplicate Join Subscriptions * * While the client may join any number of topics on any number of channels, * the client may only hold a single subscription for each unique topic at any * given time. When attempting to create a duplicate subscription, * the server will close the existing channel, log a warning, and * spawn a new channel for the topic. The client will have their * `channel.onClose` callbacks fired for the existing channel, and the new * channel join will have its receive hooks processed as normal. * * ## Pushing Messages * * From the previous example, we can see that pushing messages to the server * can be done with `channel.push(eventName, payload)` and we can optionally * receive responses from the push. Additionally, we can use * `receive("timeout", callback)` to abort waiting for our other `receive` hooks * and take action after some period of waiting. The default timeout is 10000ms. * * * ## Socket Hooks * * Lifecycle events of the multiplexed connection can be hooked into via * `socket.onError()` and `socket.onClose()` events, ie: * * ``` * socket.onError( () => console.log("there was an error with the connection!") ) * socket.onClose( () => console.log("the connection dropped") ) * ``` * * * ## Channel Hooks * * For each joined channel, you can bind to `onError` and `onClose` events * to monitor the channel lifecycle, ie: * * ``` * channel.onError( () => console.log("there was an error!") ) * channel.onClose( () => console.log("the channel has gone away gracefully") ) * ``` * * ### onError hooks * * `onError` hooks are invoked if the socket connection drops, or the channel * crashes on the server. In either case, a channel rejoin is attempted * automatically in an exponential backoff manner. * * ### onClose hooks * * `onClose` hooks are invoked only in two cases. 1) the channel explicitly * closed on the server, or 2). The client explicitly closed, by calling * `channel.leave()` * * * ## Presence * * The `Presence` object provides features for syncing presence information * from the server with the client and handling presences joining and leaving. * * ### Syncing state from the server * * To sync presence state from the server, first instantiate an object and * pass your channel in to track lifecycle events: * * ``` * let channel = socket.channel("some:topic") * let presence = new Presence(channel) * ``` * * Next, use the `presence.onSync` callback to react to state changes * from the server. For example, to render the list of users every time * the list changes, you could write: * * ``` * presence.onSync(() => { * myRenderUsersFunction(presence.list()) * }) * ``` * * ### Listing Presences * * `presence.list` is used to return a list of presence information * based on the local state of metadata. By default, all presence * metadata is returned, but a `listBy` function can be supplied to * allow the client to select which metadata to use for a given presence. * For example, you may have a user online from different devices with * a metadata status of "online", but they have set themselves to "away" * on another device. In this case, the app may choose to use the "away" * status for what appears on the UI. The example below defines a `listBy` * function which prioritizes the first metadata which was registered for * each user. This could be the first tab they opened, or the first device * they came online from: * * ``` * let listBy = (id, {metas: [first, ...rest]}) => { * first.count = rest.length + 1 // count of this user's presences * first.id = id * return first * } * let onlineUsers = presence.list(listBy) * ``` * * ### Handling individual presence join and leave events * * The `presence.onJoin` and `presence.onLeave` callbacks can be used to * react to individual presences joining and leaving the app. For example: * * ``` * let presence = new Presence(channel) * * // detect if user has joined for the 1st time or from another tab/device * presence.onJoin((id, current, newPres) => { * if(!current){ * console.log("user has entered for the first time", newPres) * } else { * console.log("user additional presence", newPres) * } * }) * * // detect if user has left from all tabs/devices, or is still present * presence.onLeave((id, current, leftPres) => { * if(current.metas.length === 0){ * console.log("user has left from all devices", leftPres) * } else { * console.log("user left from a device", leftPres) * } * }) * // receive presence data from server * presence.onSync(() => { * displayUsers(presence.list()) * }) * ``` * @module phoenix */ import Channel from "./channel" import LongPoll from "./longpoll" import Presence from "./presence" import Serializer from "./serializer" import Socket from "./socket" export { Channel, LongPoll, Presence, Serializer, Socket } ================================================ FILE: assets/js/phoenix/longpoll.js ================================================ import { SOCKET_STATES, TRANSPORTS, AUTH_TOKEN_PREFIX } from "./constants" import Ajax from "./ajax" let arrayBufferToBase64 = (buffer) => { let binary = "" let bytes = new Uint8Array(buffer) let len = bytes.byteLength for(let i = 0; i < len; i++){ binary += String.fromCharCode(bytes[i]) } return btoa(binary) } export default class LongPoll { constructor(endPoint, protocols){ // we only support subprotocols for authToken // ["phoenix", "base64url.bearer.phx.BASE64_ENCODED_TOKEN"] if(protocols && protocols.length === 2 && protocols[1].startsWith(AUTH_TOKEN_PREFIX)){ this.authToken = atob(protocols[1].slice(AUTH_TOKEN_PREFIX.length)) } this.endPoint = null this.token = null this.skipHeartbeat = true this.reqs = new Set() this.awaitingBatchAck = false this.currentBatch = null this.currentBatchTimer = null this.batchBuffer = [] this.onopen = function (){ } // noop this.onerror = function (){ } // noop this.onmessage = function (){ } // noop this.onclose = function (){ } // noop this.pollEndpoint = this.normalizeEndpoint(endPoint) this.readyState = SOCKET_STATES.connecting // we must wait for the caller to finish setting up our callbacks and timeout properties setTimeout(() => this.poll(), 0) } normalizeEndpoint(endPoint){ return (endPoint .replace("ws://", "http://") .replace("wss://", "https://") .replace(new RegExp("(.*)\/" + TRANSPORTS.websocket), "$1/" + TRANSPORTS.longpoll)) } endpointURL(){ return Ajax.appendParams(this.pollEndpoint, {token: this.token}) } closeAndRetry(code, reason, wasClean){ this.close(code, reason, wasClean) this.readyState = SOCKET_STATES.connecting } ontimeout(){ this.onerror("timeout") this.closeAndRetry(1005, "timeout", false) } isActive(){ return this.readyState === SOCKET_STATES.open || this.readyState === SOCKET_STATES.connecting } poll(){ const headers = {"Accept": "application/json"} if(this.authToken){ headers["X-Phoenix-AuthToken"] = this.authToken } this.ajax("GET", headers, null, () => this.ontimeout(), resp => { if(resp){ var {status, token, messages} = resp if(status === 410 && this.token !== null){ // In case we already have a token, this means that our existing session // is gone. We fail so that the client rejoins its channels. this.onerror(410) this.closeAndRetry(3410, "session_gone", false) return } this.token = token } else { status = 0 } switch(status){ case 200: messages.forEach(msg => { // Tasks are what things like event handlers, setTimeout callbacks, // promise resolves and more are run within. // In modern browsers, there are two different kinds of tasks, // microtasks and macrotasks. // Microtasks are mainly used for Promises, while macrotasks are // used for everything else. // Microtasks always have priority over macrotasks. If the JS engine // is looking for a task to run, it will always try to empty the // microtask queue before attempting to run anything from the // macrotask queue. // // For the WebSocket transport, messages always arrive in their own // event. This means that if any promises are resolved from within, // their callbacks will always finish execution by the time the // next message event handler is run. // // In order to emulate this behaviour, we need to make sure each // onmessage handler is run within its own macrotask. setTimeout(() => this.onmessage({data: msg}), 0) }) this.poll() break case 204: this.poll() break case 410: this.readyState = SOCKET_STATES.open this.onopen({}) this.poll() break case 403: this.onerror(403) this.close(1008, "forbidden", false) break case 0: case 500: this.onerror(500) this.closeAndRetry(1011, "internal server error", 500) break default: throw new Error(`unhandled poll status ${status}`) } }) } // we collect all pushes within the current event loop by // setTimeout 0, which optimizes back-to-back procedural // pushes against an empty buffer send(body){ if(typeof(body) !== "string"){ body = arrayBufferToBase64(body) } if(this.currentBatch){ this.currentBatch.push(body) } else if(this.awaitingBatchAck){ this.batchBuffer.push(body) } else { this.currentBatch = [body] this.currentBatchTimer = setTimeout(() => { this.batchSend(this.currentBatch) this.currentBatch = null }, 0) } } batchSend(messages){ this.awaitingBatchAck = true this.ajax("POST", {"Content-Type": "application/x-ndjson"}, messages.join("\n"), () => this.onerror("timeout"), resp => { this.awaitingBatchAck = false if(!resp || resp.status !== 200){ this.onerror(resp && resp.status) this.closeAndRetry(1011, "internal server error", false) } else if(this.batchBuffer.length > 0){ this.batchSend(this.batchBuffer) this.batchBuffer = [] } }) } close(code, reason, wasClean){ for(let req of this.reqs){ req.abort() } this.readyState = SOCKET_STATES.closed let opts = Object.assign({code: 1000, reason: undefined, wasClean: true}, {code, reason, wasClean}) this.batchBuffer = [] clearTimeout(this.currentBatchTimer) this.currentBatchTimer = null if(typeof(CloseEvent) !== "undefined"){ this.onclose(new CloseEvent("close", opts)) } else { this.onclose(opts) } } ajax(method, headers, body, onCallerTimeout, callback){ let req let ontimeout = () => { this.reqs.delete(req) onCallerTimeout() } req = Ajax.request(method, this.endpointURL(), headers, body, this.timeout, ontimeout, resp => { this.reqs.delete(req) if(this.isActive()){ callback(resp) } }) this.reqs.add(req) } } ================================================ FILE: assets/js/phoenix/presence.js ================================================ /** * Initializes the Presence * @param {Channel} channel - The Channel * @param {Object} opts - The options, * for example `{events: {state: "state", diff: "diff"}}` */ export default class Presence { constructor(channel, opts = {}){ let events = opts.events || {state: "presence_state", diff: "presence_diff"} this.state = {} this.pendingDiffs = [] this.channel = channel this.joinRef = null this.caller = { onJoin: function (){ }, onLeave: function (){ }, onSync: function (){ } } this.channel.on(events.state, newState => { let {onJoin, onLeave, onSync} = this.caller this.joinRef = this.channel.joinRef() this.state = Presence.syncState(this.state, newState, onJoin, onLeave) this.pendingDiffs.forEach(diff => { this.state = Presence.syncDiff(this.state, diff, onJoin, onLeave) }) this.pendingDiffs = [] onSync() }) this.channel.on(events.diff, diff => { let {onJoin, onLeave, onSync} = this.caller if(this.inPendingSyncState()){ this.pendingDiffs.push(diff) } else { this.state = Presence.syncDiff(this.state, diff, onJoin, onLeave) onSync() } }) } onJoin(callback){ this.caller.onJoin = callback } onLeave(callback){ this.caller.onLeave = callback } onSync(callback){ this.caller.onSync = callback } list(by){ return Presence.list(this.state, by) } inPendingSyncState(){ return !this.joinRef || (this.joinRef !== this.channel.joinRef()) } // lower-level public static API /** * Used to sync the list of presences on the server * with the client's state. An optional `onJoin` and `onLeave` callback can * be provided to react to changes in the client's local presences across * disconnects and reconnects with the server. * * @returns {Presence} */ static syncState(currentState, newState, onJoin, onLeave){ let state = this.clone(currentState) let joins = {} let leaves = {} this.map(state, (key, presence) => { if(!newState[key]){ leaves[key] = presence } }) this.map(newState, (key, newPresence) => { let currentPresence = state[key] if(currentPresence){ let newRefs = newPresence.metas.map(m => m.phx_ref) let curRefs = currentPresence.metas.map(m => m.phx_ref) let joinedMetas = newPresence.metas.filter(m => curRefs.indexOf(m.phx_ref) < 0) let leftMetas = currentPresence.metas.filter(m => newRefs.indexOf(m.phx_ref) < 0) if(joinedMetas.length > 0){ joins[key] = newPresence joins[key].metas = joinedMetas } if(leftMetas.length > 0){ leaves[key] = this.clone(currentPresence) leaves[key].metas = leftMetas } } else { joins[key] = newPresence } }) return this.syncDiff(state, {joins: joins, leaves: leaves}, onJoin, onLeave) } /** * * Used to sync a diff of presence join and leave * events from the server, as they happen. Like `syncState`, `syncDiff` * accepts optional `onJoin` and `onLeave` callbacks to react to a user * joining or leaving from a device. * * @returns {Presence} */ static syncDiff(state, diff, onJoin, onLeave){ let {joins, leaves} = this.clone(diff) if(!onJoin){ onJoin = function (){ } } if(!onLeave){ onLeave = function (){ } } this.map(joins, (key, newPresence) => { let currentPresence = state[key] state[key] = this.clone(newPresence) if(currentPresence){ let joinedRefs = state[key].metas.map(m => m.phx_ref) let curMetas = currentPresence.metas.filter(m => joinedRefs.indexOf(m.phx_ref) < 0) state[key].metas.unshift(...curMetas) } onJoin(key, currentPresence, newPresence) }) this.map(leaves, (key, leftPresence) => { let currentPresence = state[key] if(!currentPresence){ return } let refsToRemove = leftPresence.metas.map(m => m.phx_ref) currentPresence.metas = currentPresence.metas.filter(p => { return refsToRemove.indexOf(p.phx_ref) < 0 }) onLeave(key, currentPresence, leftPresence) if(currentPresence.metas.length === 0){ delete state[key] } }) return state } /** * Returns the array of presences, with selected metadata. * * @param {Object} presences * @param {Function} chooser * * @returns {Presence} */ static list(presences, chooser){ if(!chooser){ chooser = function (key, pres){ return pres } } return this.map(presences, (key, presence) => { return chooser(key, presence) }) } // private static map(obj, func){ return Object.getOwnPropertyNames(obj).map(key => func(key, obj[key])) } static clone(obj){ return JSON.parse(JSON.stringify(obj)) } } ================================================ FILE: assets/js/phoenix/push.js ================================================ /** * Initializes the Push * @param {Channel} channel - The Channel * @param {string} event - The event, for example `"phx_join"` * @param {Object} payload - The payload, for example `{user_id: 123}` * @param {number} timeout - The push timeout in milliseconds */ export default class Push { constructor(channel, event, payload, timeout){ this.channel = channel this.event = event this.payload = payload || function (){ return {} } this.receivedResp = null this.timeout = timeout this.timeoutTimer = null this.recHooks = [] this.sent = false } /** * * @param {number} timeout */ resend(timeout){ this.timeout = timeout this.reset() this.send() } /** * */ send(){ if(this.hasReceived("timeout")){ return } this.startTimeout() this.sent = true this.channel.socket.push({ topic: this.channel.topic, event: this.event, payload: this.payload(), ref: this.ref, join_ref: this.channel.joinRef() }) } /** * * @param {*} status * @param {*} callback */ receive(status, callback){ if(this.hasReceived(status)){ callback(this.receivedResp.response) } this.recHooks.push({status, callback}) return this } /** * @private */ reset(){ this.cancelRefEvent() this.ref = null this.refEvent = null this.receivedResp = null this.sent = false } /** * @private */ matchReceive({status, response, _ref}){ this.recHooks.filter(h => h.status === status) .forEach(h => h.callback(response)) } /** * @private */ cancelRefEvent(){ if(!this.refEvent){ return } this.channel.off(this.refEvent) } /** * @private */ cancelTimeout(){ clearTimeout(this.timeoutTimer) this.timeoutTimer = null } /** * @private */ startTimeout(){ if(this.timeoutTimer){ this.cancelTimeout() } this.ref = this.channel.socket.makeRef() this.refEvent = this.channel.replyEventName(this.ref) this.channel.on(this.refEvent, payload => { this.cancelRefEvent() this.cancelTimeout() this.receivedResp = payload this.matchReceive(payload) }) this.timeoutTimer = setTimeout(() => { this.trigger("timeout", {}) }, this.timeout) } /** * @private */ hasReceived(status){ return this.receivedResp && this.receivedResp.status === status } /** * @private */ trigger(status, response){ this.channel.trigger(this.refEvent, {status, response}) } } ================================================ FILE: assets/js/phoenix/serializer.js ================================================ /* The default serializer for encoding and decoding messages */ import { CHANNEL_EVENTS } from "./constants" export default { HEADER_LENGTH: 1, META_LENGTH: 4, KINDS: {push: 0, reply: 1, broadcast: 2}, encode(msg, callback){ if(msg.payload.constructor === ArrayBuffer){ return callback(this.binaryEncode(msg)) } else { let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload] return callback(JSON.stringify(payload)) } }, decode(rawPayload, callback){ if(rawPayload.constructor === ArrayBuffer){ return callback(this.binaryDecode(rawPayload)) } else { let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload) return callback({join_ref, ref, topic, event, payload}) } }, // private binaryEncode(message){ let {join_ref, ref, event, topic, payload} = message let metaLength = this.META_LENGTH + join_ref.length + ref.length + topic.length + event.length let header = new ArrayBuffer(this.HEADER_LENGTH + metaLength) let view = new DataView(header) let offset = 0 view.setUint8(offset++, this.KINDS.push) // kind view.setUint8(offset++, join_ref.length) view.setUint8(offset++, ref.length) view.setUint8(offset++, topic.length) view.setUint8(offset++, event.length) Array.from(join_ref, char => view.setUint8(offset++, char.charCodeAt(0))) Array.from(ref, char => view.setUint8(offset++, char.charCodeAt(0))) Array.from(topic, char => view.setUint8(offset++, char.charCodeAt(0))) Array.from(event, char => view.setUint8(offset++, char.charCodeAt(0))) var combined = new Uint8Array(header.byteLength + payload.byteLength) combined.set(new Uint8Array(header), 0) combined.set(new Uint8Array(payload), header.byteLength) return combined.buffer }, binaryDecode(buffer){ let view = new DataView(buffer) let kind = view.getUint8(0) let decoder = new TextDecoder() switch(kind){ case this.KINDS.push: return this.decodePush(buffer, view, decoder) case this.KINDS.reply: return this.decodeReply(buffer, view, decoder) case this.KINDS.broadcast: return this.decodeBroadcast(buffer, view, decoder) } }, decodePush(buffer, view, decoder){ let joinRefSize = view.getUint8(1) let topicSize = view.getUint8(2) let eventSize = view.getUint8(3) let offset = this.HEADER_LENGTH + this.META_LENGTH - 1 // pushes have no ref let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)) offset = offset + joinRefSize let topic = decoder.decode(buffer.slice(offset, offset + topicSize)) offset = offset + topicSize let event = decoder.decode(buffer.slice(offset, offset + eventSize)) offset = offset + eventSize let data = buffer.slice(offset, buffer.byteLength) return {join_ref: joinRef, ref: null, topic: topic, event: event, payload: data} }, decodeReply(buffer, view, decoder){ let joinRefSize = view.getUint8(1) let refSize = view.getUint8(2) let topicSize = view.getUint8(3) let eventSize = view.getUint8(4) let offset = this.HEADER_LENGTH + this.META_LENGTH let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)) offset = offset + joinRefSize let ref = decoder.decode(buffer.slice(offset, offset + refSize)) offset = offset + refSize let topic = decoder.decode(buffer.slice(offset, offset + topicSize)) offset = offset + topicSize let event = decoder.decode(buffer.slice(offset, offset + eventSize)) offset = offset + eventSize let data = buffer.slice(offset, buffer.byteLength) let payload = {status: event, response: data} return {join_ref: joinRef, ref: ref, topic: topic, event: CHANNEL_EVENTS.reply, payload: payload} }, decodeBroadcast(buffer, view, decoder){ let topicSize = view.getUint8(1) let eventSize = view.getUint8(2) let offset = this.HEADER_LENGTH + 2 let topic = decoder.decode(buffer.slice(offset, offset + topicSize)) offset = offset + topicSize let event = decoder.decode(buffer.slice(offset, offset + eventSize)) offset = offset + eventSize let data = buffer.slice(offset, buffer.byteLength) return {join_ref: null, ref: null, topic: topic, event: event, payload: data} } } ================================================ FILE: assets/js/phoenix/socket.js ================================================ import { global, phxWindow, CHANNEL_EVENTS, DEFAULT_TIMEOUT, DEFAULT_VSN, SOCKET_STATES, TRANSPORTS, WS_CLOSE_NORMAL, AUTH_TOKEN_PREFIX } from "./constants" import { closure } from "./utils" import Ajax from "./ajax" import Channel from "./channel" import LongPoll from "./longpoll" import Serializer from "./serializer" import Timer from "./timer" /** Initializes the Socket * * * For IE8 support use an ES5-shim (https://github.com/es-shims/es5-shim) * * @param {string} endPoint - The string WebSocket endpoint, ie, `"ws://example.com/socket"`, * `"wss://example.com"` * `"/socket"` (inherited host & protocol) * @param {Object} [opts] - Optional configuration * @param {Function} [opts.transport] - The Websocket Transport, for example WebSocket or Phoenix.LongPoll. * * Defaults to WebSocket with automatic LongPoll fallback if WebSocket is not defined. * To fallback to LongPoll when WebSocket attempts fail, use `longPollFallbackMs: 2500`. * * @param {number} [opts.longPollFallbackMs] - The millisecond time to attempt the primary transport * before falling back to the LongPoll transport. Disabled by default. * * @param {boolean} [opts.debug] - When true, enables debug logging. Default false. * * @param {Function} [opts.encode] - The function to encode outgoing messages. * * Defaults to JSON encoder. * * @param {Function} [opts.decode] - The function to decode incoming messages. * * Defaults to JSON: * * ```javascript * (payload, callback) => callback(JSON.parse(payload)) * ``` * * @param {number} [opts.timeout] - The default timeout in milliseconds to trigger push timeouts. * * Defaults `DEFAULT_TIMEOUT` * @param {number} [opts.heartbeatIntervalMs] - The millisec interval to send a heartbeat message * @param {Function} [opts.reconnectAfterMs] - The optional function that returns the * socket reconnect interval, in milliseconds. * * Defaults to stepped backoff of: * * ```javascript * function(tries){ * return [10, 50, 100, 150, 200, 250, 500, 1000, 2000][tries - 1] || 5000 * } * ```` * * @param {Function} [opts.rejoinAfterMs] - The optional function that returns the millisec * rejoin interval for individual channels. * * ```javascript * function(tries){ * return [1000, 2000, 5000][tries - 1] || 10000 * } * ```` * * @param {Function} [opts.logger] - The optional function for specialized logging, ie: * * ```javascript * function(kind, msg, data) { * console.log(`${kind}: ${msg}`, data) * } * ``` * * @param {number} [opts.longpollerTimeout] - The maximum timeout of a long poll AJAX request. * * Defaults to 20s (double the server long poll timer). * * @param {(Object|function)} [opts.params] - The optional params to pass when connecting * @param {string} [opts.authToken] - the optional authentication token to be exposed on the server * under the `:auth_token` connect_info key. * @param {string} [opts.binaryType] - The binary type to use for binary WebSocket frames. * * Defaults to "arraybuffer" * * @param {vsn} [opts.vsn] - The serializer's protocol version to send on connect. * * Defaults to DEFAULT_VSN. * * @param {Object} [opts.sessionStorage] - An optional Storage compatible object * Phoenix uses sessionStorage for longpoll fallback history. Overriding the store is * useful when Phoenix won't have access to `sessionStorage`. For example, This could * happen if a site loads a cross-domain channel in an iframe. Example usage: * * class InMemoryStorage { * constructor() { this.storage = {} } * getItem(keyName) { return this.storage[keyName] || null } * removeItem(keyName) { delete this.storage[keyName] } * setItem(keyName, keyValue) { this.storage[keyName] = keyValue } * } * */ export default class Socket { constructor(endPoint, opts = {}){ this.stateChangeCallbacks = {open: [], close: [], error: [], message: []} this.channels = [] this.sendBuffer = [] this.ref = 0 this.fallbackRef = null this.timeout = opts.timeout || DEFAULT_TIMEOUT this.transport = opts.transport || global.WebSocket || LongPoll this.primaryPassedHealthCheck = false this.longPollFallbackMs = opts.longPollFallbackMs this.fallbackTimer = null this.sessionStore = opts.sessionStorage || (global && global.sessionStorage) this.establishedConnections = 0 this.defaultEncoder = Serializer.encode.bind(Serializer) this.defaultDecoder = Serializer.decode.bind(Serializer) // We start with closeWasClean true to avoid the visibility change // logic from connecting if the socket was never connected in the first place. // transportConnect sets it to false on open. this.closeWasClean = true this.disconnecting = false this.binaryType = opts.binaryType || "arraybuffer" this.connectClock = 1 this.pageHidden = false if(this.transport !== LongPoll){ this.encode = opts.encode || this.defaultEncoder this.decode = opts.decode || this.defaultDecoder } else { this.encode = this.defaultEncoder this.decode = this.defaultDecoder } let awaitingConnectionOnPageShow = null if(phxWindow && phxWindow.addEventListener){ phxWindow.addEventListener("pagehide", _e => { if(this.conn){ this.disconnect() awaitingConnectionOnPageShow = this.connectClock } }) phxWindow.addEventListener("pageshow", _e => { if(awaitingConnectionOnPageShow === this.connectClock){ awaitingConnectionOnPageShow = null this.connect() } }) phxWindow.addEventListener("visibilitychange", () => { if(document.visibilityState === "hidden"){ this.pageHidden = true } else { this.pageHidden = false // reconnect immediately if(!this.isConnected() && !this.closeWasClean){ this.teardown(() => this.connect()) } } }) } this.heartbeatIntervalMs = opts.heartbeatIntervalMs || 30000 this.rejoinAfterMs = (tries) => { if(opts.rejoinAfterMs){ return opts.rejoinAfterMs(tries) } else { return [1000, 2000, 5000][tries - 1] || 10000 } } this.reconnectAfterMs = (tries) => { if(opts.reconnectAfterMs){ return opts.reconnectAfterMs(tries) } else { return [10, 50, 100, 150, 200, 250, 500, 1000, 2000][tries - 1] || 5000 } } this.logger = opts.logger || null if(!this.logger && opts.debug){ this.logger = (kind, msg, data) => { console.log(`${kind}: ${msg}`, data) } } this.longpollerTimeout = opts.longpollerTimeout || 20000 this.params = closure(opts.params || {}) this.endPoint = `${endPoint}/${TRANSPORTS.websocket}` this.vsn = opts.vsn || DEFAULT_VSN this.heartbeatTimeoutTimer = null this.heartbeatTimer = null this.pendingHeartbeatRef = null this.reconnectTimer = new Timer(() => { if(this.pageHidden){ this.log("Not reconnecting as page is hidden!") this.teardown() return } this.teardown(() => this.connect()) }, this.reconnectAfterMs) this.authToken = opts.authToken } /** * Returns the LongPoll transport reference */ getLongPollTransport(){ return LongPoll } /** * Disconnects and replaces the active transport * * @param {Function} newTransport - The new transport class to instantiate * */ replaceTransport(newTransport){ this.connectClock++ this.closeWasClean = true clearTimeout(this.fallbackTimer) this.reconnectTimer.reset() if(this.conn){ this.conn.close() this.conn = null } this.transport = newTransport } /** * Returns the socket protocol * * @returns {string} */ protocol(){ return location.protocol.match(/^https/) ? "wss" : "ws" } /** * The fully qualified socket url * * @returns {string} */ endPointURL(){ let uri = Ajax.appendParams( Ajax.appendParams(this.endPoint, this.params()), {vsn: this.vsn}) if(uri.charAt(0) !== "/"){ return uri } if(uri.charAt(1) === "/"){ return `${this.protocol()}:${uri}` } return `${this.protocol()}://${location.host}${uri}` } /** * Disconnects the socket * * See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes for valid status codes. * * @param {Function} callback - Optional callback which is called after socket is disconnected. * @param {integer} code - A status code for disconnection (Optional). * @param {string} reason - A textual description of the reason to disconnect. (Optional) */ disconnect(callback, code, reason){ this.connectClock++ this.disconnecting = true this.closeWasClean = true clearTimeout(this.fallbackTimer) this.reconnectTimer.reset() this.teardown(() => { this.disconnecting = false callback && callback() }, code, reason) } /** * * @param {Object} params - The params to send when connecting, for example `{user_id: userToken}` * * Passing params to connect is deprecated; pass them in the Socket constructor instead: * `new Socket("/socket", {params: {user_id: userToken}})`. */ connect(params){ if(params){ console && console.log("passing params to connect is deprecated. Instead pass :params to the Socket constructor") this.params = closure(params) } if(this.conn && !this.disconnecting){ return } if(this.longPollFallbackMs && this.transport !== LongPoll){ this.connectWithFallback(LongPoll, this.longPollFallbackMs) } else { this.transportConnect() } } /** * Logs the message. Override `this.logger` for specialized logging. noops by default * @param {string} kind * @param {string} msg * @param {Object} data */ log(kind, msg, data){ this.logger && this.logger(kind, msg, data) } /** * Returns true if a logger has been set on this socket. */ hasLogger(){ return this.logger !== null } /** * Registers callbacks for connection open events * * @example socket.onOpen(function(){ console.info("the socket was opened") }) * * @param {Function} callback */ onOpen(callback){ let ref = this.makeRef() this.stateChangeCallbacks.open.push([ref, callback]) return ref } /** * Registers callbacks for connection close events * @param {Function} callback */ onClose(callback){ let ref = this.makeRef() this.stateChangeCallbacks.close.push([ref, callback]) return ref } /** * Registers callbacks for connection error events * * @example socket.onError(function(error){ alert("An error occurred") }) * * @param {Function} callback */ onError(callback){ let ref = this.makeRef() this.stateChangeCallbacks.error.push([ref, callback]) return ref } /** * Registers callbacks for connection message events * @param {Function} callback */ onMessage(callback){ let ref = this.makeRef() this.stateChangeCallbacks.message.push([ref, callback]) return ref } /** * Pings the server and invokes the callback with the RTT in milliseconds * @param {Function} callback * * Returns true if the ping was pushed or false if unable to be pushed. */ ping(callback){ if(!this.isConnected()){ return false } let ref = this.makeRef() let startTime = Date.now() this.push({topic: "phoenix", event: "heartbeat", payload: {}, ref: ref}) let onMsgRef = this.onMessage(msg => { if(msg.ref === ref){ this.off([onMsgRef]) callback(Date.now() - startTime) } }) return true } /** * @private * * @param {Function} */ transportName(transport){ // JavaScript minification, enabled by default in production in Phoenix // projects, renames symbols to reduce code size. // See https://esbuild.github.io/api/#keep-names. // This helper ensures we return the correct name for the LongPoll transport // even after minification. The other common transport is WebSocket, which // is native to browsers and does not need special handling. switch(transport){ case LongPoll: return "LongPoll" default: return transport.name } } /** * @private */ transportConnect(){ this.connectClock++ this.closeWasClean = false let protocols = undefined // Sec-WebSocket-Protocol based token // (longpoll uses Authorization header instead) if(this.authToken){ protocols = ["phoenix", `${AUTH_TOKEN_PREFIX}${btoa(this.authToken).replace(/=/g, "")}`] } this.conn = new this.transport(this.endPointURL(), protocols) this.conn.binaryType = this.binaryType this.conn.timeout = this.longpollerTimeout this.conn.onopen = () => this.onConnOpen() this.conn.onerror = error => this.onConnError(error) this.conn.onmessage = event => this.onConnMessage(event) this.conn.onclose = event => this.onConnClose(event) } getSession(key){ return this.sessionStore && this.sessionStore.getItem(key) } storeSession(key, val){ this.sessionStore && this.sessionStore.setItem(key, val) } connectWithFallback(fallbackTransport, fallbackThreshold = 2500){ clearTimeout(this.fallbackTimer) let established = false let primaryTransport = true let openRef, errorRef let fallbackTransportName = this.transportName(fallbackTransport) let fallback = (reason) => { this.log("transport", `falling back to ${fallbackTransportName}...`, reason) this.off([openRef, errorRef]) primaryTransport = false this.replaceTransport(fallbackTransport) this.transportConnect() } if(this.getSession(`phx:fallback:${fallbackTransportName}`)){ return fallback("memorized") } this.fallbackTimer = setTimeout(fallback, fallbackThreshold) errorRef = this.onError(reason => { this.log("transport", "error", reason) if(primaryTransport && !established){ clearTimeout(this.fallbackTimer) fallback(reason) } }) if(this.fallbackRef){ this.off([this.fallbackRef]) } this.fallbackRef = this.onOpen(() => { established = true if(!primaryTransport){ let fallbackTransportName = this.transportName(fallbackTransport) // only memorize LP if we never connected to primary if(!this.primaryPassedHealthCheck){ this.storeSession(`phx:fallback:${fallbackTransportName}`, "true") } return this.log("transport", `established ${fallbackTransportName} fallback`) } // if we've established primary, give the fallback a new period to attempt ping clearTimeout(this.fallbackTimer) this.fallbackTimer = setTimeout(fallback, fallbackThreshold) this.ping(rtt => { this.log("transport", "connected to primary after", rtt) this.primaryPassedHealthCheck = true clearTimeout(this.fallbackTimer) }) }) this.transportConnect() } clearHeartbeats(){ clearTimeout(this.heartbeatTimer) clearTimeout(this.heartbeatTimeoutTimer) } onConnOpen(){ if(this.hasLogger()) this.log("transport", `${this.transportName(this.transport)} connected to ${this.endPointURL()}`) this.closeWasClean = false this.disconnecting = false this.establishedConnections++ this.flushSendBuffer() this.reconnectTimer.reset() this.resetHeartbeat() this.stateChangeCallbacks.open.forEach(([, callback]) => callback()) } /** * @private */ heartbeatTimeout(){ if(this.pendingHeartbeatRef){ this.pendingHeartbeatRef = null if(this.hasLogger()){ this.log("transport", "heartbeat timeout. Attempting to re-establish connection") } this.triggerChanError() this.closeWasClean = false this.teardown(() => this.reconnectTimer.scheduleTimeout(), WS_CLOSE_NORMAL, "heartbeat timeout") } } resetHeartbeat(){ if(this.conn && this.conn.skipHeartbeat){ return } this.pendingHeartbeatRef = null this.clearHeartbeats() this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs) } teardown(callback, code, reason){ if(!this.conn){ return callback && callback() } // If someone calls connect before we finish tearing down, // we create a new connection, but we still want to finish tearing down the old one. const connToClose = this.conn this.waitForBufferDone(connToClose, () => { if(code){ connToClose.close(code, reason || "") } else { connToClose.close() } this.waitForSocketClosed(connToClose, () => { if(this.conn === connToClose){ this.conn.onopen = function (){ } // noop this.conn.onerror = function (){ } // noop this.conn.onmessage = function (){ } // noop this.conn.onclose = function (){ } // noop this.conn = null } callback && callback() }) }) } waitForBufferDone(conn, callback, tries = 1){ if(tries === 5 || !conn.bufferedAmount){ callback() return } setTimeout(() => { this.waitForBufferDone(conn, callback, tries + 1) }, 150 * tries) } waitForSocketClosed(conn, callback, tries = 1){ if(tries === 5 || conn.readyState === SOCKET_STATES.closed){ callback() return } setTimeout(() => { this.waitForSocketClosed(conn, callback, tries + 1) }, 150 * tries) } onConnClose(event){ if(this.conn) this.conn.onclose = () => {} // noop to prevent recursive calls in teardown let closeCode = event && event.code if(this.hasLogger()) this.log("transport", "close", event) this.triggerChanError() this.clearHeartbeats() if(!this.closeWasClean && closeCode !== 1000){ this.reconnectTimer.scheduleTimeout() } this.stateChangeCallbacks.close.forEach(([, callback]) => callback(event)) } /** * @private */ onConnError(error){ if(this.hasLogger()) this.log("transport", error) let transportBefore = this.transport let establishedBefore = this.establishedConnections this.stateChangeCallbacks.error.forEach(([, callback]) => { callback(error, transportBefore, establishedBefore) }) if(transportBefore === this.transport || establishedBefore > 0){ this.triggerChanError() } } /** * @private */ triggerChanError(){ this.channels.forEach(channel => { if(!(channel.isErrored() || channel.isLeaving() || channel.isClosed())){ channel.trigger(CHANNEL_EVENTS.error) } }) } /** * @returns {string} */ connectionState(){ switch(this.conn && this.conn.readyState){ case SOCKET_STATES.connecting: return "connecting" case SOCKET_STATES.open: return "open" case SOCKET_STATES.closing: return "closing" default: return "closed" } } /** * @returns {boolean} */ isConnected(){ return this.connectionState() === "open" } /** * @private * * @param {Channel} */ remove(channel){ this.off(channel.stateChangeRefs) this.channels = this.channels.filter(c => c !== channel) } /** * Removes `onOpen`, `onClose`, `onError,` and `onMessage` registrations. * * @param {refs} - list of refs returned by calls to * `onOpen`, `onClose`, `onError,` and `onMessage` */ off(refs){ for(let key in this.stateChangeCallbacks){ this.stateChangeCallbacks[key] = this.stateChangeCallbacks[key].filter(([ref]) => { return refs.indexOf(ref) === -1 }) } } /** * Initiates a new channel for the given topic * * @param {string} topic * @param {Object} chanParams - Parameters for the channel * @returns {Channel} */ channel(topic, chanParams = {}){ let chan = new Channel(topic, chanParams, this) this.channels.push(chan) return chan } /** * @param {Object} data */ push(data){ if(this.hasLogger()){ let {topic, event, payload, ref, join_ref} = data this.log("push", `${topic} ${event} (${join_ref}, ${ref})`, payload) } if(this.isConnected()){ this.encode(data, result => this.conn.send(result)) } else { this.sendBuffer.push(() => this.encode(data, result => this.conn.send(result))) } } /** * Return the next message ref, accounting for overflows * @returns {string} */ makeRef(){ let newRef = this.ref + 1 if(newRef === this.ref){ this.ref = 0 } else { this.ref = newRef } return this.ref.toString() } sendHeartbeat(){ if(this.pendingHeartbeatRef && !this.isConnected()){ return } this.pendingHeartbeatRef = this.makeRef() this.push({topic: "phoenix", event: "heartbeat", payload: {}, ref: this.pendingHeartbeatRef}) this.heartbeatTimeoutTimer = setTimeout(() => this.heartbeatTimeout(), this.heartbeatIntervalMs) } flushSendBuffer(){ if(this.isConnected() && this.sendBuffer.length > 0){ this.sendBuffer.forEach(callback => callback()) this.sendBuffer = [] } } onConnMessage(rawMessage){ this.decode(rawMessage.data, msg => { let {topic, event, payload, ref, join_ref} = msg if(ref && ref === this.pendingHeartbeatRef){ this.clearHeartbeats() this.pendingHeartbeatRef = null this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs) } if(this.hasLogger()) this.log("receive", `${payload.status || ""} ${topic} ${event} ${ref && "(" + ref + ")" || ""}`, payload) for(let i = 0; i < this.channels.length; i++){ const channel = this.channels[i] if(!channel.isMember(topic, event, payload, join_ref)){ continue } channel.trigger(event, payload, ref, join_ref) } for(let i = 0; i < this.stateChangeCallbacks.message.length; i++){ let [, callback] = this.stateChangeCallbacks.message[i] callback(msg) } }) } leaveOpenTopic(topic){ let dupChannel = this.channels.find(c => c.topic === topic && (c.isJoined() || c.isJoining())) if(dupChannel){ if(this.hasLogger()) this.log("transport", `leaving duplicate topic "${topic}"`) dupChannel.leave() } } } ================================================ FILE: assets/js/phoenix/timer.js ================================================ /** * * Creates a timer that accepts a `timerCalc` function to perform * calculated timeout retries, such as exponential backoff. * * @example * let reconnectTimer = new Timer(() => this.connect(), function(tries){ * return [1000, 5000, 10000][tries - 1] || 10000 * }) * reconnectTimer.scheduleTimeout() // fires after 1000 * reconnectTimer.scheduleTimeout() // fires after 5000 * reconnectTimer.reset() * reconnectTimer.scheduleTimeout() // fires after 1000 * * @param {Function} callback * @param {Function} timerCalc */ export default class Timer { constructor(callback, timerCalc){ this.callback = callback this.timerCalc = timerCalc this.timer = null this.tries = 0 } reset(){ this.tries = 0 clearTimeout(this.timer) } /** * Cancels any previous scheduleTimeout and schedules callback */ scheduleTimeout(){ clearTimeout(this.timer) this.timer = setTimeout(() => { this.tries = this.tries + 1 this.callback() }, this.timerCalc(this.tries + 1)) } } ================================================ FILE: assets/js/phoenix/utils.js ================================================ // wraps value in closure or returns closure export let closure = (value) => { if(typeof value === "function"){ return value } else { let closure = function (){ return value } return closure } } ================================================ FILE: assets/test/channel_test.js ================================================ import {jest} from "@jest/globals" import {Channel, Socket} from "../js/phoenix" let channel, socket const defaultRef = 1 const defaultTimeout = 10000 class WSMock { constructor(url, protocols){ this.url = url this.protocols = protocols } close(){} send(){} } describe("with transport", function (){ beforeAll(function (){ global.WebSocket = WSMock }) afterAll(function (){ global.WebSocket = null }) describe("constructor", function (){ beforeEach(function (){ socket = new Socket("/", {timeout: 1234}) }) it("sets defaults", function (){ channel = new Channel("topic", {one: "two"}, socket) expect(channel.state).toBe("closed") expect(channel.topic).toBe("topic") expect(channel.params()).toEqual({one: "two"}) expect(channel.socket).toBe(socket) expect(channel.timeout).toBe(1234) expect(channel.joinedOnce).toBe(false) expect(channel.joinPush).toBeTruthy() expect(channel.pushBuffer).toEqual([]) }) it("sets up joinPush object with literal params", function (){ channel = new Channel("topic", {one: "two"}, socket) const joinPush = channel.joinPush expect(joinPush.channel).toBe(channel) expect(joinPush.payload()).toEqual({one: "two"}) expect(joinPush.event).toBe("phx_join") expect(joinPush.timeout).toBe(1234) }) it("sets up joinPush object with closure params", function (){ channel = new Channel("topic", () => ({one: "two"}), socket) const joinPush = channel.joinPush expect(joinPush.channel).toBe(channel) expect(joinPush.payload()).toEqual({one: "two"}) expect(joinPush.event).toBe("phx_join") expect(joinPush.timeout).toBe(1234) }) it("sets subprotocols when authToken is provided", function (){ const authToken = "1234" const socket = new Socket("/socket", {authToken}) socket.connect() expect(socket.conn.protocols).toEqual(["phoenix", "base64url.bearer.phx.MTIzNA"]) }) }) describe("updating join params", function (){ it("can update the join params", function (){ let counter = 0 let params = () => ({value: counter}) socket = {timeout: 1234, onError: function (){}, onOpen: function (){}} channel = new Channel("topic", params, socket) const joinPush = channel.joinPush expect(joinPush.channel).toBe(channel) expect(joinPush.payload()).toEqual({value: 0}) expect(joinPush.event).toBe("phx_join") expect(joinPush.timeout).toBe(1234) counter++ expect(joinPush.channel).toBe(channel) expect(joinPush.payload()).toEqual({value: 1}) expect(channel.params()).toEqual({value: 1}) expect(joinPush.event).toBe("phx_join") expect(joinPush.timeout).toBe(1234) }) }) describe("join", function (){ beforeEach(function (){ socket = new Socket("/socket", {timeout: defaultTimeout}) channel = socket.channel("topic", {one: "two"}) }) it("sets state to joining", function (){ channel.join() expect(channel.state).toBe("joining") }) it("sets joinedOnce to true", function (){ expect(channel.joinedOnce).toBe(false) channel.join() expect(channel.joinedOnce).toBe(true) }) it("throws if attempting to join multiple times", function (){ channel.join() expect(() => channel.join()).toThrow(/^tried to join multiple times/) }) it("triggers socket push with channel params", function (){ jest.spyOn(socket, "makeRef").mockReturnValue(defaultRef) const spy = jest.spyOn(socket, "push") channel.join() expect(spy).toHaveBeenCalledTimes(1) expect(spy).toHaveBeenCalledWith({ topic: "topic", event: "phx_join", payload: {one: "two"}, ref: defaultRef, join_ref: channel.joinRef(), }) }) it("can set timeout on joinPush", function (){ const newTimeout = 2000 const joinPush = channel.joinPush expect(joinPush.timeout).toBe(defaultTimeout) channel.join(newTimeout) expect(joinPush.timeout).toBe(newTimeout) }) it("leaves existing duplicate topic on new join", function (done){ channel.join().receive("ok", () => { let newChannel = socket.channel("topic") expect(channel.isJoined()).toBe(true) newChannel.join() expect(channel.isJoined()).toBe(false) done() }) channel.joinPush.trigger("ok", {}) }) describe("timeout behavior", function (){ let joinPush const helpers = { receiveSocketOpen(){ jest.spyOn(socket, "isConnected").mockReturnValue(true) socket.onConnOpen() }, } beforeEach(function (){ jest.useFakeTimers() joinPush = channel.joinPush }) afterEach(function (){ jest.useRealTimers() }) it("succeeds before timeout", function (){ const spy = jest.spyOn(socket, "push") const timeout = joinPush.timeout socket.connect() helpers.receiveSocketOpen() channel.join() expect(spy).toHaveBeenCalledTimes(1) expect(channel.timeout).toBe(10000) jest.advanceTimersByTime(100) joinPush.trigger("ok", {}) expect(channel.state).toBe("joined") jest.advanceTimersByTime(timeout) expect(spy).toHaveBeenCalledTimes(1) }) it("retries with backoff after timeout", function (){ const spy = jest.spyOn(socket, "push") const timeoutSpy = jest.fn() const timeout = joinPush.timeout socket.connect() helpers.receiveSocketOpen() channel.join().receive("timeout", timeoutSpy) expect(spy).toHaveBeenCalledTimes(1) expect(timeoutSpy).toHaveBeenCalledTimes(0) jest.advanceTimersByTime(timeout) expect(spy).toHaveBeenCalledTimes(2) // leave pushed to server expect(timeoutSpy).toHaveBeenCalledTimes(1) jest.advanceTimersByTime(timeout + 1000) expect(spy).toHaveBeenCalledTimes(4) // leave + rejoin expect(timeoutSpy).toHaveBeenCalledTimes(2) jest.advanceTimersByTime(10000) joinPush.trigger("ok", {}) expect(spy).toHaveBeenCalledTimes(6) expect(channel.state).toBe("joined") }) it("with socket and join delay", function (){ const spy = jest.spyOn(socket, "push") jest.useFakeTimers() const joinPush = channel.joinPush channel.join() expect(spy).toHaveBeenCalledTimes(1) // open socket after delay jest.advanceTimersByTime(9000) expect(spy).toHaveBeenCalledTimes(1) // join request returns between timeouts jest.advanceTimersByTime(1000) socket.connect() expect(channel.state).toBe("errored") helpers.receiveSocketOpen() joinPush.trigger("ok", {}) // join request succeeds after delay jest.advanceTimersByTime(1000) expect(channel.state).toBe("joined") expect(spy).toHaveBeenCalledTimes(3) // leave pushed to server }) it("with socket delay only", function (){ jest.useFakeTimers() const joinPush = channel.joinPush channel.join() expect(channel.state).toBe("joining") // connect socket after delay jest.advanceTimersByTime(6000) socket.connect() // open socket after delay jest.advanceTimersByTime(5000) helpers.receiveSocketOpen() joinPush.trigger("ok", {}) joinPush.trigger("ok", {}) expect(channel.state).toBe("joined") }) }) }) describe("joinPush", function (){ let joinPush let response const helpers = { receiveOk(){ jest.advanceTimersByTime(joinPush.timeout / 2) // before timeout return joinPush.channel.trigger("phx_reply", {status: "ok", response: response}, joinPush.ref, joinPush.ref) // return joinPush.trigger("ok", response) }, receiveTimeout(){ jest.advanceTimersByTime(joinPush.timeout * 2) // after timeout }, receiveError(){ jest.advanceTimersByTime(joinPush.timeout / 2) // before timeout return joinPush.trigger("error", response) }, getBindings(event){ return channel.bindings.filter(bind => bind.event === event) }, } beforeEach(function (){ jest.useFakeTimers() socket = new Socket("/socket", {timeout: defaultTimeout}) jest.spyOn(socket, "isConnected").mockReturnValue(true) jest.spyOn(socket, "push").mockReturnValue(true) channel = socket.channel("topic", {one: "two"}) joinPush = channel.joinPush channel.join() }) afterEach(function (){ jest.useRealTimers() }) describe("receives 'ok'", function (){ beforeEach(function (){ response = {chan: "reply"} }) it("sets channel state to joined", function (){ expect(channel.state).not.toBe("joined") helpers.receiveOk() expect(channel.state).toBe("joined") }) it("triggers receive('ok') callback after ok response", function (){ const spyOk = jest.fn() joinPush.receive("ok", spyOk) helpers.receiveOk() expect(spyOk).toHaveBeenCalledTimes(1) }) it("triggers receive('ok') callback if ok response already received", function (){ const spyOk = jest.fn() helpers.receiveOk() joinPush.receive("ok", spyOk) expect(spyOk).toHaveBeenCalledTimes(1) }) it("does not trigger other receive callbacks after ok response", function (){ const spyError = jest.fn() const spyTimeout = jest.fn() joinPush.receive("error", spyError).receive("timeout", spyTimeout) helpers.receiveOk() jest.advanceTimersByTime(channel.timeout * 2) // attempt timeout expect(spyError).not.toHaveBeenCalled() expect(spyTimeout).not.toHaveBeenCalled() }) it("clears timeoutTimer", function (){ expect(joinPush.timeoutTimer).toBeTruthy() helpers.receiveOk() expect(joinPush.timeoutTimer).toBeNull() }) it("sets receivedResp", function (){ expect(joinPush.receivedResp).toBeNull() helpers.receiveOk() expect(joinPush.receivedResp).toEqual({status: "ok", response}) }) it("removes channel bindings", function (){ let bindings = helpers.getBindings("chan_reply_3") expect(bindings.length).toBe(1) helpers.receiveOk() bindings = helpers.getBindings("chan_reply_3") expect(bindings.length).toBe(0) }) it("resets channel rejoinTimer", function (){ expect(channel.rejoinTimer).toBeTruthy() const spy = jest.spyOn(channel.rejoinTimer, "reset") helpers.receiveOk() expect(spy).toHaveBeenCalledTimes(1) }) it("sends and empties channel's buffered pushEvents", function (done){ const pushEvent = {send(){}} const spy = jest.spyOn(pushEvent, "send") channel.pushBuffer.push(pushEvent) expect(channel.state).toBe("joining") joinPush.receive("ok", () => { expect(spy).toHaveBeenCalledTimes(1) expect(channel.pushBuffer.length).toBe(0) done() }) helpers.receiveOk() }) }) describe("receives 'timeout'", function (){ it("sets channel state to errored", function (done){ joinPush.receive("timeout", () => { expect(channel.state).toBe("errored") done() }) helpers.receiveTimeout() }) it("triggers receive('timeout') callback after ok response", function (){ const spyTimeout = jest.fn() joinPush.receive("timeout", spyTimeout) helpers.receiveTimeout() expect(spyTimeout).toHaveBeenCalledTimes(1) }) it("does not trigger other receive callbacks after timeout response", function (done){ const spyOk = jest.fn() const spyError = jest.fn() jest.spyOn(channel.rejoinTimer, "scheduleTimeout").mockReturnValue(true) channel.test = true joinPush.receive("ok", spyOk).receive("error", spyError).receive("timeout", () => { expect(spyOk).not.toHaveBeenCalled() expect(spyError).not.toHaveBeenCalled() done() }) helpers.receiveTimeout() helpers.receiveOk() }) it("schedules rejoinTimer timeout", function (){ expect(channel.rejoinTimer).toBeTruthy() const spy = jest.spyOn(channel.rejoinTimer, "scheduleTimeout") helpers.receiveTimeout() expect(spy).toHaveBeenCalled() // TODO why called multiple times? }) }) describe("receives 'error'", function (){ beforeEach(function (){ response = {chan: "fail"} }) it("triggers receive('error') callback after error response", function (){ const spyError = jest.fn() expect(channel.state).toBe("joining") joinPush.receive("error", spyError) helpers.receiveError() joinPush.trigger("error", {}) expect(spyError).toHaveBeenCalledTimes(1) }) it("triggers receive('error') callback if error response already received", function (){ const spyError = jest.fn() helpers.receiveError() joinPush.receive("error", spyError) expect(spyError).toHaveBeenCalledTimes(1) }) it("does not trigger other receive callbacks after error response", function (){ const spyOk = jest.fn() const spyError = jest.fn() const spyTimeout = jest.fn() joinPush.receive("ok", spyOk).receive("error", () => { spyError() channel.leave() }).receive("timeout", spyTimeout) helpers.receiveError() jest.advanceTimersByTime(channel.timeout * 2) // attempt timeout expect(spyError).toHaveBeenCalledTimes(1) expect(spyOk).not.toHaveBeenCalled() expect(spyTimeout).not.toHaveBeenCalled() }) it("clears timeoutTimer", function (){ expect(joinPush.timeoutTimer).toBeTruthy() helpers.receiveError() expect(joinPush.timeoutTimer).toBeNull() }) it("sets receivedResp with error trigger after binding", function (done){ expect(joinPush.receivedResp).toBeNull() joinPush.receive("error", resp => { expect(resp).toEqual(response) done() }) helpers.receiveError() }) it("sets receivedResp with error trigger before binding", function (done){ expect(joinPush.receivedResp).toBeNull() helpers.receiveError() joinPush.receive("error", resp => { expect(resp).toEqual(response) done() }) }) it("does not set channel state to joined", function (){ helpers.receiveError() expect(channel.state).toBe("errored") }) it("does not trigger channel's buffered pushEvents", function (){ const pushEvent = {send: () => {}} const spy = jest.spyOn(pushEvent, "send") channel.pushBuffer.push(pushEvent) helpers.receiveError() expect(spy).not.toHaveBeenCalled() expect(channel.pushBuffer.length).toBe(1) }) }) }) describe("onError", function (){ let joinPush beforeEach(function (){ jest.useFakeTimers() socket = new Socket("/socket", {timeout: defaultTimeout}) jest.spyOn(socket, "isConnected").mockReturnValue(true) jest.spyOn(socket, "push").mockReturnValue(true) channel = socket.channel("topic", {one: "two"}) joinPush = channel.joinPush channel.join() joinPush.trigger("ok", {}) }) afterEach(function (){ jest.useRealTimers() }) it("sets state to 'errored'", function (){ expect(channel.state).not.toBe("errored") channel.trigger("phx_error") expect(channel.state).toBe("errored") }) it("does not trigger redundant errors during backoff", function (){ const spy = jest.spyOn(joinPush, "send").mockImplementation(() => {}) expect(spy).toHaveBeenCalledTimes(0) channel.trigger("phx_error") jest.advanceTimersByTime(1000) expect(spy).toHaveBeenCalledTimes(1) joinPush.trigger("error", {}) jest.advanceTimersByTime(10000) expect(spy).toHaveBeenCalledTimes(1) }) it("does not rejoin if channel leaving", function (){ channel.state = "leaving" const spy = jest.spyOn(joinPush, "send") socket.onConnError({}) jest.advanceTimersByTime(1000) expect(spy).toHaveBeenCalledTimes(0) jest.advanceTimersByTime(2000) expect(spy).toHaveBeenCalledTimes(0) expect(channel.state).toBe("leaving") }) it("does not rejoin if channel closed", function (){ channel.state = "closed" const spy = jest.spyOn(joinPush, "send") socket.onConnError({}) jest.advanceTimersByTime(1000) expect(spy).toHaveBeenCalledTimes(0) jest.advanceTimersByTime(2000) expect(spy).toHaveBeenCalledTimes(0) expect(channel.state).toBe("closed") }) it("triggers additional callbacks after join", function (){ const spy = jest.fn() channel.onError(spy) joinPush.trigger("ok", {}) expect(channel.state).toBe("joined") expect(spy).toHaveBeenCalledTimes(0) channel.trigger("phx_error") expect(spy).toHaveBeenCalledTimes(1) }) }) describe("onClose", function (){ let joinPush beforeEach(function (){ jest.useFakeTimers() socket = new Socket("/socket", {timeout: defaultTimeout}) jest.spyOn(socket, "isConnected").mockReturnValue(true) jest.spyOn(socket, "push").mockReturnValue(true) channel = socket.channel("topic", {one: "two"}) joinPush = channel.joinPush channel.join() }) afterEach(function (){ jest.useRealTimers() }) it("sets state to 'closed'", function (){ expect(channel.state).not.toBe("closed") channel.trigger("phx_close") expect(channel.state).toBe("closed") }) it("does not rejoin", function (){ const spy = jest.spyOn(joinPush, "send") channel.trigger("phx_close") jest.advanceTimersByTime(1000) expect(spy).toHaveBeenCalledTimes(0) jest.advanceTimersByTime(2000) expect(spy).toHaveBeenCalledTimes(0) }) it("triggers additional callbacks", function (){ const spy = jest.fn() channel.onClose(spy) expect(spy).toHaveBeenCalledTimes(0) channel.trigger("phx_close") expect(spy).toHaveBeenCalledTimes(1) }) it("removes channel from socket", function (){ expect(socket.channels.length).toBe(1) expect(socket.channels[0]).toBe(channel) channel.trigger("phx_close") expect(socket.channels.length).toBe(0) }) }) describe("onMessage", function (){ it("returns payload by default", function (){ socket = new Socket("/socket") channel = socket.channel("topic", {one: "two"}) jest.spyOn(socket, "makeRef").mockReturnValue(defaultRef) const payload = channel.onMessage("event", {one: "two"}, defaultRef) expect(payload).toEqual({one: "two"}) }) }) describe("canPush", function (){ beforeEach(function (){ socket = new Socket("/socket") channel = socket.channel("topic", {one: "two"}) }) it("returns true when socket connected and channel joined", function (){ jest.spyOn(socket, "isConnected").mockReturnValue(true) channel.state = "joined" expect(channel.canPush()).toBe(true) }) it("otherwise returns false", function (){ const isConnectedStub = jest.spyOn(socket, "isConnected") isConnectedStub.mockReturnValue(false) channel.state = "joined" expect(channel.canPush()).toBe(false) isConnectedStub.mockReturnValue(true) channel.state = "joining" expect(channel.canPush()).toBe(false) isConnectedStub.mockReturnValue(false) channel.state = "joining" expect(channel.canPush()).toBe(false) }) }) describe("on", function (){ beforeEach(function (){ socket = new Socket("/socket") jest.spyOn(socket, "makeRef").mockReturnValue(defaultRef) channel = socket.channel("topic", {one: "two"}) }) it("sets up callback for event", function (){ const spy = jest.fn() channel.trigger("event", {}, defaultRef) expect(spy).not.toHaveBeenCalled() channel.on("event", spy) channel.trigger("event", {}, defaultRef) expect(spy).toHaveBeenCalled() }) it("other event callbacks are ignored", function (){ const spy = jest.fn() const ignoredSpy = jest.fn() channel.trigger("event", {}, defaultRef) expect(ignoredSpy).not.toHaveBeenCalled() channel.on("event", spy) channel.trigger("event", {}, defaultRef) expect(ignoredSpy).not.toHaveBeenCalled() }) it("generates unique refs for callbacks", function (){ const ref1 = channel.on("event1", () => 0) const ref2 = channel.on("event2", () => 0) expect(ref1 + 1).toBe(ref2) }) it("calls all callbacks for event if they modified during event processing", function (){ const spy = jest.fn() const ref = channel.on("event", () => { channel.off("event", ref) }) channel.on("event", spy) channel.trigger("event", {}, defaultRef) expect(spy).toHaveBeenCalled() }) }) describe("off", function (){ beforeEach(function (){ socket = new Socket("/socket") jest.spyOn(socket, "makeRef").mockReturnValue(defaultRef) channel = socket.channel("topic", {one: "two"}) }) it("removes all callbacks for event", function (){ const spy1 = jest.fn() const spy2 = jest.fn() const spy3 = jest.fn() channel.on("event", spy1) channel.on("event", spy2) channel.on("other", spy3) channel.off("event") channel.trigger("event", {}, defaultRef) channel.trigger("other", {}, defaultRef) expect(spy1).not.toHaveBeenCalled() expect(spy2).not.toHaveBeenCalled() expect(spy3).toHaveBeenCalled() }) it("removes callback by its ref", function (){ const spy1 = jest.fn() const spy2 = jest.fn() const ref1 = channel.on("event", spy1) const _ref2 = channel.on("event", spy2) channel.off("event", ref1) channel.trigger("event", {}, defaultRef) expect(spy1).not.toHaveBeenCalled() expect(spy2).toHaveBeenCalled() }) }) describe("push", function (){ let joinPush let socketSpy const pushParams = (channel) => { return { topic: "topic", event: "event", payload: {foo: "bar"}, join_ref: channel.joinRef(), ref: defaultRef, } } beforeEach(function (){ jest.useFakeTimers() socket = new Socket("/socket", {timeout: defaultTimeout}) jest.spyOn(socket, "makeRef").mockReturnValue(defaultRef) jest.spyOn(socket, "isConnected").mockReturnValue(true) socketSpy = jest.spyOn(socket, "push").mockReturnValue(undefined) channel = socket.channel("topic", {one: "two"}) }) afterEach(function (){ jest.useRealTimers() }) it("sends push event when successfully joined", function (){ channel.join().trigger("ok", {}) channel.push("event", {foo: "bar"}) expect(socketSpy).toHaveBeenCalledWith(pushParams(channel)) }) it("enqueues push event to be sent once join has succeeded", function (){ joinPush = channel.join() channel.push("event", {foo: "bar"}) expect(socketSpy).not.toHaveBeenCalledWith(pushParams(channel)) jest.advanceTimersByTime(channel.timeout / 2) joinPush.trigger("ok", {}) expect(socketSpy).toHaveBeenCalledWith(pushParams(channel)) }) it("does not push if channel join times out", function (){ joinPush = channel.join() channel.push("event", {foo: "bar"}) expect(socketSpy).not.toHaveBeenCalledWith(pushParams(channel)) jest.advanceTimersByTime(channel.timeout * 2) joinPush.trigger("ok", {}) expect(socketSpy).not.toHaveBeenCalledWith(pushParams(channel)) }) it("uses channel timeout by default", function (){ const timeoutSpy = jest.fn() channel.join().trigger("ok", {}) channel.push("event", {foo: "bar"}).receive("timeout", timeoutSpy) jest.advanceTimersByTime(channel.timeout / 2) expect(timeoutSpy).not.toHaveBeenCalled() jest.advanceTimersByTime(channel.timeout) expect(timeoutSpy).toHaveBeenCalled() }) it("accepts timeout arg", function (){ const timeoutSpy = jest.fn() channel.join().trigger("ok", {}) channel.push("event", {foo: "bar"}, channel.timeout * 2).receive("timeout", timeoutSpy) jest.advanceTimersByTime(channel.timeout) expect(timeoutSpy).not.toHaveBeenCalled() jest.advanceTimersByTime(channel.timeout * 2) expect(timeoutSpy).toHaveBeenCalled() }) it("does not time out after receiving 'ok'", function (){ channel.join().trigger("ok", {}) const timeoutSpy = jest.fn() const push = channel.push("event", {foo: "bar"}) push.receive("timeout", timeoutSpy) jest.advanceTimersByTime(push.timeout / 2) expect(timeoutSpy).not.toHaveBeenCalled() push.trigger("ok", {}) jest.advanceTimersByTime(push.timeout) expect(timeoutSpy).not.toHaveBeenCalled() }) it("throws if channel has not been joined", function (){ expect(() => channel.push("event", {})).toThrow(/^tried to push.*before joining/) }) }) describe("leave", function (){ let socketSpy beforeEach(function (){ jest.useFakeTimers() socket = new Socket("/socket", {timeout: defaultTimeout}) jest.spyOn(socket, "isConnected").mockReturnValue(true) socketSpy = jest.spyOn(socket, "push").mockReturnValue(undefined) channel = socket.channel("topic", {one: "two"}) channel.join().trigger("ok", {}) }) afterEach(function (){ jest.useRealTimers() }) it("unsubscribes from server events", function (){ jest.spyOn(socket, "makeRef").mockReturnValue(defaultRef) const joinRef = channel.joinRef() channel.leave() expect(socketSpy).toHaveBeenCalledWith({ topic: "topic", event: "phx_leave", payload: {}, ref: defaultRef, join_ref: joinRef, }) }) it("closes channel on 'ok' from server", function (){ const anotherChannel = socket.channel("another", {three: "four"}) expect(socket.channels.length).toBe(2) channel.leave().trigger("ok", {}) expect(socket.channels.length).toBe(1) expect(socket.channels[0]).toBe(anotherChannel) }) it("sets state to closed on 'ok' event", function (){ expect(channel.state).not.toBe("closed") channel.leave().trigger("ok", {}) expect(channel.state).toBe("closed") }) // TODO - the following tests are skipped until Channel.leave // behavior can be fixed; currently, 'ok' is triggered immediately // within Channel.leave so timeout callbacks are never reached // it.skip("sets state to leaving initially", function (){ expect(channel.state).not.toBe("leaving") channel.leave() expect(channel.state).toBe("leaving") }) it.skip("closes channel on 'timeout'", function (){ channel.leave() jest.advanceTimersByTime(channel.timeout) expect(channel.state).toBe("closed") }) it.skip("accepts timeout arg", function (){ channel.leave(channel.timeout * 2) jest.advanceTimersByTime(channel.timeout) expect(channel.state).toBe("leaving") jest.advanceTimersByTime(channel.timeout * 2) expect(channel.state).toBe("closed") }) }) }) ================================================ FILE: assets/test/longpoll_test.js ================================================ import {jest} from "@jest/globals" import {LongPoll} from "../js/phoenix" import {Socket} from "../js/phoenix" import {AUTH_TOKEN_PREFIX} from "../js/phoenix/constants" import Ajax from "../js/phoenix/ajax" describe("LongPoll", () => { let originalXHR beforeEach(() => { originalXHR = global.XMLHttpRequest // Mock XMLHttpRequest const mockOpen = jest.fn() const mockSend = jest.fn() const mockAbort = jest.fn() const mockSetRequestHeader = jest.fn() global.XMLHttpRequest = jest.fn(() => ({ open: mockOpen, send: mockSend, abort: mockAbort, setRequestHeader: mockSetRequestHeader, readyState: 4, status: 200, responseText: JSON.stringify({status: 200, token: "token123", messages: []}), onreadystatechange: null, })) // Spy on Ajax.request jest.spyOn(Ajax, "request").mockImplementation(() => { return {abort: jest.fn()} }) }) afterEach(() => { global.XMLHttpRequest = originalXHR jest.restoreAllMocks() }) describe("constructor", () => { it("should handle undefined protocols", () => { const longpoll = new LongPoll("http://localhost/socket/longpoll", undefined) // Verify longpoll was initialized correctly without error expect(longpoll.pollEndpoint).toBe("http://localhost/socket/longpoll") expect(longpoll.authToken).toBeUndefined() expect(longpoll.readyState).toBe(0) // connecting }) it("should handle null protocols", () => { const longpoll = new LongPoll("http://localhost/socket/longpoll", null) // Verify longpoll was initialized correctly without error expect(longpoll.pollEndpoint).toBe("http://localhost/socket/longpoll") expect(longpoll.authToken).toBeUndefined() expect(longpoll.readyState).toBe(0) // connecting }) it("should handle empty array protocols", () => { const longpoll = new LongPoll("http://localhost/socket/longpoll", []) // Verify longpoll was initialized correctly without error expect(longpoll.pollEndpoint).toBe("http://localhost/socket/longpoll") expect(longpoll.authToken).toBeUndefined() expect(longpoll.readyState).toBe(0) // connecting }) it("should extract authToken when valid protocols are provided", () => { const authToken = "my-auth-token" const encodedToken = btoa(authToken) const protocols = ["phoenix", `${AUTH_TOKEN_PREFIX}${encodedToken}`] const longpoll = new LongPoll("http://localhost/socket/longpoll", protocols) // Verify auth token was extracted correctly expect(longpoll.authToken).toBe(authToken) }) }) describe("poll", () => { it("should include auth token in headers when present", () => { const authToken = "my-auth-token" const encodedToken = btoa(authToken) const protocols = ["phoenix", `${AUTH_TOKEN_PREFIX}${encodedToken}`] const longpoll = new LongPoll("http://localhost/socket/longpoll", protocols) longpoll.timeout = 1000 longpoll.poll() // Verify Ajax.request was called with the correct headers expect(Ajax.request).toHaveBeenCalledWith( "GET", expect.any(String), {"Accept": "application/json", "X-Phoenix-AuthToken": authToken}, null, expect.any(Number), expect.any(Function), expect.any(Function) ) }) it("should not include auth token in headers when not present", () => { const longpoll = new LongPoll("http://localhost/socket/longpoll", undefined) longpoll.timeout = 1000 longpoll.poll() // Verify Ajax.request was called without auth token header expect(Ajax.request).toHaveBeenCalledWith( "GET", expect.any(String), {"Accept": "application/json"}, null, expect.any(Number), expect.any(Function), expect.any(Function) ) }) it("should treat 410 as error when token already exists", () => { const longpoll = new LongPoll("http://localhost/socket/longpoll", undefined) longpoll.timeout = 1000 longpoll.token = "existing-token" const mockOnerror = jest.fn() const mockCloseAndRetry = jest.fn() longpoll.onerror = mockOnerror longpoll.closeAndRetry = mockCloseAndRetry Ajax.request.mockImplementation((method, url, headers, body, timeout, ontimeout, callback) => { callback({status: 410, token: "new-token", messages: []}) return {abort: jest.fn()} }) longpoll.poll() expect(mockOnerror).toHaveBeenCalledWith(410) expect(mockCloseAndRetry).toHaveBeenCalledWith(3410, "session_gone", false) }) }) describe("batchSend", () => { it("should send with correct content-type header format", () => { const longpoll = new LongPoll("http://localhost/socket/longpoll", undefined) longpoll.timeout = 1000 const messages = ["message1", "message2"] longpoll.batchSend(messages) // Verify Ajax.request was called with correct headers format expect(Ajax.request).toHaveBeenCalledWith( "POST", expect.any(String), {"Content-Type": "application/x-ndjson"}, "message1\nmessage2", expect.any(Number), expect.any(Function), expect.any(Function) ) }) }) }) describe("Socket with LongPoll", () => { describe("transportConnect", () => { it("should initialize with undefined protocols when no auth token", () => { const socket = new Socket("/socket", {transport: LongPoll}) // Mock the transport to capture the protocols argument socket.transport = jest.fn(() => ({ onopen: jest.fn(), onerror: jest.fn(), onmessage: jest.fn(), onclose: jest.fn() })) socket.transportConnect() // Verify that the transport was called with undefined protocols expect(socket.transport).toHaveBeenCalledWith( expect.any(String), undefined ) }) it("should only set protocols array when auth token is present", () => { const authToken = "my-auth-token" const socket = new Socket("/socket", { transport: LongPoll, params: {token: authToken} }) // Set auth token socket.authToken = authToken // Mock the transport to capture the protocols argument socket.transport = jest.fn(() => ({ onopen: jest.fn(), onerror: jest.fn(), onmessage: jest.fn(), onclose: jest.fn() })) socket.transportConnect() // Verify that the transport was called with correct protocols array expect(socket.transport).toHaveBeenCalledWith( expect.any(String), ["phoenix", `${AUTH_TOKEN_PREFIX}${btoa(authToken).replace(/=/g, "")}`] ) }) }) }) describe("Ajax.request", () => { let originalXMLHttpRequest, originalFetch, originalAbortController beforeEach(() => { originalXMLHttpRequest = global.XMLHttpRequest originalFetch = global.fetch originalAbortController = global.AbortController // Mock AbortController global.AbortController = jest.fn(() => ({ abort: jest.fn(), signal: {} })) // Mock XMLHttpRequest global.XMLHttpRequest = jest.fn(() => ({ open: jest.fn(), send: jest.fn(), setRequestHeader: jest.fn(), onreadystatechange: null, readyState: 4, status: 200, responseText: JSON.stringify({success: true}) })) // Mock fetch global.fetch = jest.fn(() => Promise.resolve({ text: () => Promise.resolve(JSON.stringify({success: true})) }) ) }) afterEach(() => { global.XMLHttpRequest = originalXMLHttpRequest global.fetch = originalFetch global.AbortController = originalAbortController jest.restoreAllMocks() }) it("should use XMLHttpRequest by default", () => { Ajax.request("GET", "/test-endpoint", {}, null, 0, null, (response) => { expect(response).toEqual({success: true}) }) expect(global.XMLHttpRequest).toHaveBeenCalled() }) it("should use fetch when XMLHttpRequest is not available", () => { global.XMLHttpRequest = undefined // Simulate it being unavailable Ajax.request("GET", "/test-endpoint", {}, null, 0, null, (response) => { expect(response).toEqual({success: true}) }) expect(global.fetch).toHaveBeenCalledWith( "/test-endpoint", expect.objectContaining({ method: "GET", }) ) }) }) ================================================ FILE: assets/test/presence_test.js ================================================ import {Presence} from "../js/phoenix" const clone = (obj) => { let cloned = JSON.parse(JSON.stringify(obj)) Object.entries(obj).forEach(([key, val]) => { if(val === undefined){ cloned[key] = undefined } }) return cloned } const fixtures = { joins(){ return {u1: {metas: [{id: 1, phx_ref: "1.2"}]}} }, leaves(){ return {u2: {metas: [{id: 2, phx_ref: "2"}]}} }, state(){ return { u1: {metas: [{id: 1, phx_ref: "1"}]}, u2: {metas: [{id: 2, phx_ref: "2"}]}, u3: {metas: [{id: 3, phx_ref: "3"}]}, } }, } const channelStub = { ref: 1, events: {}, on(event, callback){ this.events[event] = callback }, trigger(event, data){ this.events[event](data) }, joinRef(){ return `${this.ref}` }, simulateDisconnectAndReconnect(){ this.ref++ }, } const listByFirst = (id, {metas: [first, ..._rest]}) => first describe("syncState", () => { it("syncs empty state", () => { let newState = {u1: {metas: [{id: 1, phx_ref: "1"}]}} let state = {} let stateBefore = clone(state) Presence.syncState(state, newState) expect(state).toEqual(stateBefore) state = Presence.syncState(state, newState) expect(state).toEqual(newState) }) it("onJoins new presences and onLeave's left presences", () => { let newState = fixtures.state() let state = {u4: {metas: [{id: 4, phx_ref: "4"}]}} let joined = {} let left = {} const onJoin = (key, current, newPres) => { joined[key] = {current, newPres} } const onLeave = (key, current, leftPres) => { left[key] = {current, leftPres} } state = Presence.syncState(state, newState, onJoin, onLeave) expect(state).toEqual(newState) expect(joined).toEqual({ u1: {current: undefined, newPres: {metas: [{id: 1, phx_ref: "1"}]}}, u2: {current: undefined, newPres: {metas: [{id: 2, phx_ref: "2"}]}}, u3: {current: undefined, newPres: {metas: [{id: 3, phx_ref: "3"}]}}, }) expect(left).toEqual({ u4: {current: {metas: []}, leftPres: {metas: [{id: 4, phx_ref: "4"}]}}, }) }) it("onJoins only newly added metas", () => { let newState = {u3: {metas: [{id: 3, phx_ref: "3"}, {id: 3, phx_ref: "3.new"}]}} let state = {u3: {metas: [{id: 3, phx_ref: "3"}]}} let joined = [] let left = [] const onJoin = (key, current, newPres) => { joined.push([key, clone({current, newPres})]) } const onLeave = (key, current, leftPres) => { left.push([key, clone({current, leftPres})]) } state = Presence.syncState(state, clone(newState), onJoin, onLeave) expect(state).toEqual(newState) expect(joined).toEqual([ ["u3", {current: {metas: [{id: 3, phx_ref: "3"}]}, newPres: {metas: [{id: 3, phx_ref: "3.new"}]}}], ]) expect(left).toEqual([]) }) }) describe("syncDiff", () => { it("syncs empty state", () => { let joins = {u1: {metas: [{id: 1, phx_ref: "1"}]}} let state = Presence.syncDiff({}, {joins, leaves: {}}) expect(state).toEqual(joins) }) it("removes presence when meta is empty and adds additional meta", () => { let state = fixtures.state() state = Presence.syncDiff(state, {joins: fixtures.joins(), leaves: fixtures.leaves()}) expect(state).toEqual({ u1: {metas: [{id: 1, phx_ref: "1"}, {id: 1, phx_ref: "1.2"}]}, u3: {metas: [{id: 3, phx_ref: "3"}]}, }) }) it("removes meta while leaving key if other metas exist", () => { let state = {u1: {metas: [{id: 1, phx_ref: "1"}, {id: 1, phx_ref: "1.2"}]}} state = Presence.syncDiff(state, {joins: {}, leaves: {u1: {metas: [{id: 1, phx_ref: "1"}]}}}) expect(state).toEqual({ u1: {metas: [{id: 1, phx_ref: "1.2"}]}, }) }) }) describe("list", () => { it("lists full presence by default", () => { let state = fixtures.state() expect(Presence.list(state)).toEqual([ {metas: [{id: 1, phx_ref: "1"}]}, {metas: [{id: 2, phx_ref: "2"}]}, {metas: [{id: 3, phx_ref: "3"}]}, ]) }) it("lists with custom function", () => { let state = {u1: {metas: [{id: 1, phx_ref: "1.first"}, {id: 1, phx_ref: "1.second"}]}} const listBy = (key, {metas: [first, ..._rest]}) => first expect(Presence.list(state, listBy)).toEqual([{id: 1, phx_ref: "1.first"}]) }) }) describe("instance", () => { it("syncs state and diffs", () => { let presence = new Presence(channelStub) let user1 = {metas: [{id: 1, phx_ref: "1"}]} let user2 = {metas: [{id: 2, phx_ref: "2"}]} let newState = {u1: user1, u2: user2} channelStub.trigger("presence_state", newState) expect(presence.list(listByFirst)).toEqual([{id: 1, phx_ref: "1"}, {id: 2, phx_ref: "2"}]) channelStub.trigger("presence_diff", {joins: {}, leaves: {u1: user1}}) expect(presence.list(listByFirst)).toEqual([{id: 2, phx_ref: "2"}]) }) it("applies pending diff if state is not yet synced", () => { let presence = new Presence(channelStub) let onJoins = [] let onLeaves = [] presence.onJoin((id, current, newPres) => { onJoins.push(clone({id, current, newPres})) }) presence.onLeave((id, current, leftPres) => { onLeaves.push(clone({id, current, leftPres})) }) let user1 = {metas: [{id: 1, phx_ref: "1"}]} let user2 = {metas: [{id: 2, phx_ref: "2"}]} let user3 = {metas: [{id: 3, phx_ref: "3"}]} let newState = {u1: user1, u2: user2} let leaves = {u2: user2} channelStub.trigger("presence_diff", {joins: {}, leaves: leaves}) expect(presence.list(listByFirst)).toEqual([]) expect(presence.pendingDiffs).toEqual([{joins: {}, leaves: leaves}]) channelStub.trigger("presence_state", newState) expect(onLeaves).toEqual([{id: "u2", current: {metas: []}, leftPres: {metas: [{id: 2, phx_ref: "2"}]}}]) expect(presence.list(listByFirst)).toEqual([{id: 1, phx_ref: "1"}]) expect(presence.pendingDiffs).toEqual([]) expect(onJoins).toEqual([ {id: "u1", current: undefined, newPres: {metas: [{id: 1, phx_ref: "1"}]}}, {id: "u2", current: undefined, newPres: {metas: [{id: 2, phx_ref: "2"}]}}, ]) channelStub.simulateDisconnectAndReconnect() expect(presence.inPendingSyncState()).toBe(true) channelStub.trigger("presence_diff", {joins: {}, leaves: {u1: user1}}) expect(presence.list(listByFirst)).toEqual([{id: 1, phx_ref: "1"}]) channelStub.trigger("presence_state", {u1: user1, u3: user3}) expect(presence.list(listByFirst)).toEqual([{id: 3, phx_ref: "3"}]) }) it("allows custom channel events", () => { let presence = new Presence(channelStub, { events: { state: "the_state", diff: "the_diff", }, }) let user1 = {metas: [{id: 1, phx_ref: "1"}]} channelStub.trigger("the_state", {user1}) expect(presence.list(listByFirst)).toEqual([{id: 1, phx_ref: "1"}]) channelStub.trigger("the_diff", {joins: {}, leaves: {user1}}) expect(presence.list(listByFirst)).toEqual([]) }) it("updates existing meta for a presence update (leave + join)", () => { let presence = new Presence(channelStub) let onJoins = [] let onLeaves = [] let user1 = {metas: [{id: 1, phx_ref: "1"}]} let user2 = {metas: [{id: 2, name: "chris", phx_ref: "2"}]} let newState = {u1: user1, u2: user2} channelStub.trigger("presence_state", clone(newState)) presence.onJoin((id, current, newPres) => { onJoins.push(clone({id, current, newPres})) }) presence.onLeave((id, current, leftPres) => { onLeaves.push(clone({id, current, leftPres})) }) expect(presence.list((id, {metas: metas}) => metas)).toEqual([ [{id: 1, phx_ref: "1"}], [{id: 2, name: "chris", phx_ref: "2"}], ]) let leaves = {u2: user2} let joins = {u2: {metas: [{id: 2, name: "chris.2", phx_ref: "2.2", phx_ref_prev: "2"}]}} channelStub.trigger("presence_diff", {joins, leaves}) expect(presence.list((id, {metas: metas}) => metas)).toEqual([ [{id: 1, phx_ref: "1"}], [{id: 2, name: "chris.2", phx_ref: "2.2", phx_ref_prev: "2"}], ]) expect(onJoins).toEqual([ { id: "u2", current: {metas: [{id: 2, name: "chris", phx_ref: "2"}]}, newPres: {metas: [{id: 2, name: "chris.2", phx_ref: "2.2", phx_ref_prev: "2"}]}, }, ]) }) }) ================================================ FILE: assets/test/serializer.js ================================================ export const encode = (msg) => { let payload = [ msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload ] return JSON.stringify(payload) } export const decode = (rawPayload) => { let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload) return {join_ref, ref, topic, event, payload} } ================================================ FILE: assets/test/serializer_test.js ================================================ /** * @jest-environment node */ import {TextEncoder, TextDecoder} from "util" import {Serializer} from "../js/phoenix" let exampleMsg = {join_ref: "0", ref: "1", topic: "t", event: "e", payload: {foo: 1}} let binPayload = () => { let buffer = new ArrayBuffer(1) new DataView(buffer).setUint8(0, 1) return buffer } describe("JSON", () => { it("encodes general pushes", (done) => { Serializer.encode(exampleMsg, (result) => { expect(result).toBe("[\"0\",\"1\",\"t\",\"e\",{\"foo\":1}]") done() }) }) it("decodes", (done) => { Serializer.decode("[\"0\",\"1\",\"t\",\"e\",{\"foo\":1}]", (result) => { expect(result).toEqual(exampleMsg) done() }) }) }) describe("binary", () => { it("encodes", (done) => { let buffer = binPayload() let bin = "\0\x01\x01\x01\x0101te\x01" let decoder = new TextDecoder() Serializer.encode({join_ref: "0", ref: "1", topic: "t", event: "e", payload: buffer}, (result) => { expect(decoder.decode(result)).toBe(bin) done() }) }) it("encodes variable length segments", (done) => { let buffer = binPayload() let bin = "\0\x02\x01\x03\x02101topev\x01" let decoder = new TextDecoder() Serializer.encode({join_ref: "10", ref: "1", topic: "top", event: "ev", payload: buffer}, (result) => { expect(decoder.decode(result)).toBe(bin) done() }) }) it("decodes push", (done) => { let bin = "\0\x03\x03\n123topsome-event\x01\x01" let buffer = new TextEncoder().encode(bin).buffer let decoder = new TextDecoder() Serializer.decode(buffer, (result) => { expect(result.join_ref).toBe("123") expect(result.ref).toBeNull() expect(result.topic).toBe("top") expect(result.event).toBe("some-event") expect(result.payload.constructor).toBe(ArrayBuffer) expect(decoder.decode(result.payload)).toBe("\x01\x01") done() }) }) it("decodes reply", (done) => { let bin = "\x01\x03\x02\x03\x0210012topok\x01\x01" let buffer = new TextEncoder().encode(bin).buffer let decoder = new TextDecoder() Serializer.decode(buffer, (result) => { expect(result.join_ref).toBe("100") expect(result.ref).toBe("12") expect(result.topic).toBe("top") expect(result.event).toBe("phx_reply") expect(result.payload.status).toBe("ok") expect(result.payload.response.constructor).toBe(ArrayBuffer) expect(decoder.decode(result.payload.response)).toBe("\x01\x01") done() }) }) it("decodes broadcast", (done) => { let bin = "\x02\x03\ntopsome-event\x01\x01" let buffer = new TextEncoder().encode(bin).buffer let decoder = new TextDecoder() Serializer.decode(buffer, (result) => { expect(result.join_ref).toBeNull() expect(result.ref).toBeNull() expect(result.topic).toBe("top") expect(result.event).toBe("some-event") expect(result.payload.constructor).toBe(ArrayBuffer) expect(decoder.decode(result.payload)).toBe("\x01\x01") done() }) }) }) ================================================ FILE: assets/test/socket_http_test.js ================================================ /** * @jest-environment jsdom * @jest-environment-options {"url": "http://example.com/"} */ import {Socket} from "../js/phoenix" // sadly, jsdom can only be configured globally for a file describe("protocol", function (){ it("returns ws when location.protocol is http", function (){ const socket = new Socket("/socket") expect(socket.protocol()).toBe("ws") }) }) describe("endpointURL", function (){ it("returns endpoint for given path on http host", function (){ const socket = new Socket("/socket") expect(socket.endPointURL()).toBe( "ws://example.com/socket/websocket?vsn=2.0.0", ) }) }) ================================================ FILE: assets/test/socket_test.js ================================================ import {jest} from "@jest/globals" import {WebSocket, Server as WebSocketServer} from "mock-socket" import {encode} from "./serializer" import {Socket, LongPoll} from "../js/phoenix" import {SOCKET_STATES} from "../js/phoenix/constants" let socket describe("with transports", function (){ beforeAll(() => { window.WebSocket = WebSocket const mockOpen = jest.fn() const mockSend = jest.fn() const mockAbort = jest.fn() const mockSetRequestHeader = jest.fn() global.XMLHttpRequest = jest.fn(() => ({ open: mockOpen, send: mockSend, abort: mockAbort, setRequestHeader: mockSetRequestHeader, readyState: 4, status: 200, responseText: JSON.stringify({}), onreadystatechange: null, })) }) describe("constructor", function (){ it("sets defaults", function (){ socket = new Socket("/socket") expect(socket.channels.length).toBe(0) expect(socket.sendBuffer.length).toBe(0) expect(socket.ref).toBe(0) expect(socket.endPoint).toBe("/socket/websocket") expect(socket.stateChangeCallbacks).toEqual({open: [], close: [], error: [], message: []}) expect(socket.transport).toBe(WebSocket) expect(socket.timeout).toBe(10000) expect(socket.longpollerTimeout).toBe(20000) expect(socket.heartbeatIntervalMs).toBe(30000) expect(socket.logger).toBeNull() expect(socket.binaryType).toBe("arraybuffer") expect(typeof socket.reconnectAfterMs).toBe("function") }) it("supports closure or literal params", function (){ socket = new Socket("/socket", {params: {one: "two"}}) expect(socket.params()).toEqual({one: "two"}) socket = new Socket("/socket", {params: function (){ return ({three: "four"}) }}) expect(socket.params()).toEqual({three: "four"}) }) it("overrides some defaults with options", function (){ const customTransport = function transport(){ } const customLogger = function logger(){ } const customReconnect = function reconnect(){ } socket = new Socket("/socket", { timeout: 40000, longpollerTimeout: 50000, heartbeatIntervalMs: 60000, transport: customTransport, logger: customLogger, reconnectAfterMs: customReconnect, params: {one: "two"}, }) expect(socket.timeout).toBe(40000) expect(socket.longpollerTimeout).toBe(50000) expect(socket.heartbeatIntervalMs).toBe(60000) expect(socket.transport).toBe(customTransport) expect(socket.logger).toBe(customLogger) expect(socket.params()).toEqual({one: "two"}) }) describe("with Websocket", function (){ it("defaults to Websocket transport if available", function (done){ let mockServer = new WebSocketServer("wss://example.com/") socket = new Socket("/socket") expect(socket.transport).toBe(WebSocket) mockServer.stop(() => done()) }) }) describe("longPollFallbackMs", function (){ it("falls back to longpoll when set after primary transport failure", function (done){ let mockServer socket = new Socket("/socket", {longPollFallbackMs: 20}) const replaceSpy = jest.spyOn(socket, "replaceTransport") mockServer = new WebSocketServer("wss://example.test/") mockServer.stop(() => { expect(socket.transport).toBe(WebSocket) socket.onError((_reason) => { setTimeout(() => { expect(replaceSpy).toHaveBeenCalledWith(LongPoll) done() }, 100) }) socket.connect() }) }) }) }) describe("visibilitychange", function (){ it("does not connect a socket that was never connected", function (){ socket = new Socket("/socket") const teardownSpy = jest.spyOn(socket, "teardown") Object.defineProperty(document, "visibilityState", {value: "hidden", writable: true}) window.dispatchEvent(new Event("visibilitychange")) Object.defineProperty(document, "visibilityState", {value: "visible", writable: true}) window.dispatchEvent(new Event("visibilitychange")) expect(teardownSpy).not.toHaveBeenCalled() }) it("reconnects on visibility change after unclean close", function (){ socket = new Socket("/socket") socket.closeWasClean = false const teardownSpy = jest.spyOn(socket, "teardown") Object.defineProperty(document, "visibilityState", {value: "visible", writable: true}) window.dispatchEvent(new Event("visibilitychange")) expect(teardownSpy).toHaveBeenCalledTimes(1) }) it("does not reconnect on visibility change after clean close", function (){ socket = new Socket("/socket") socket.closeWasClean = true const teardownSpy = jest.spyOn(socket, "teardown") Object.defineProperty(document, "visibilityState", {value: "visible", writable: true}) window.dispatchEvent(new Event("visibilitychange")) expect(teardownSpy).not.toHaveBeenCalled() }) }) describe("protocol", function (){ beforeEach(function (){ socket = new Socket("/socket") }) it("returns wss when location.protocol is https", function (){ expect(socket.protocol()).toBe("wss") }) }) describe("endpointURL", function (){ it("returns endpoint for given full url", function (){ socket = new Socket("wss://example.org/chat") expect(socket.endPointURL()).toBe("wss://example.org/chat/websocket?vsn=2.0.0") }) it("returns endpoint for given protocol-relative url", function (){ socket = new Socket("//example.org/chat") expect(socket.endPointURL()).toBe("wss://example.org/chat/websocket?vsn=2.0.0") }) it("returns endpoint for given path on https host", function (){ socket = new Socket("/socket") expect(socket.endPointURL()).toBe("wss://example.com/socket/websocket?vsn=2.0.0") }) }) describe("connect with WebSocket", function (){ let mockServer beforeAll(function (){ mockServer = new WebSocketServer("wss://example.com/") }) afterAll(function (done){ mockServer.stop(() => done()) }) beforeEach(function (){ socket = new Socket("/socket") }) it("establishes websocket connection with endpoint", function (){ socket.connect() const conn = socket.conn expect(conn instanceof WebSocket).toBeTruthy() expect(conn.url).toBe(socket.endPointURL()) }) it("sets callbacks for connection", function (){ let opens = 0 socket.onOpen(() => ++opens) let closes = 0 socket.onClose(() => ++closes) let lastError socket.onError((error) => lastError = error) let lastMessage socket.onMessage((message) => lastMessage = message.payload) socket.connect() socket.conn.onopen() expect(opens).toBe(1) socket.conn.onclose() expect(closes).toBe(1) socket.conn.onerror("error") expect(lastError).toBe("error") const data = {"topic": "topic", "event": "event", "payload": "payload", "status": "ok"} socket.conn.onmessage({data: encode(data)}) expect(lastMessage).toBe("payload") }) it("is idempotent", function (){ socket.connect() const conn = socket.conn socket.connect() expect(conn).toBe(socket.conn) }) }) describe("connect with long poll", function (){ beforeEach(function (){ socket = new Socket("/socket", {transport: LongPoll}) }) it("establishes long poll connection with endpoint", function (){ socket.connect() const conn = socket.conn expect(conn instanceof LongPoll).toBeTruthy() expect(conn.pollEndpoint).toBe("https://example.com/socket/longpoll?vsn=2.0.0") expect(conn.timeout).toBe(20000) }) it("sets callbacks for connection", function (){ let opens = 0 socket.onOpen(() => ++opens) let closes = 0 socket.onClose(() => ++closes) let lastError socket.onError((error) => lastError = error) let lastMessage socket.onMessage((message) => lastMessage = message.payload) socket.connect() socket.conn.onopen() expect(opens).toBe(1) socket.conn.onclose() expect(closes).toBe(1) socket.conn.onerror("error") expect(lastError).toBe("error") socket.connect() const data = {"topic": "topic", "event": "event", "payload": "payload", "status": "ok"} socket.conn.onmessage({data: encode(data)}) expect(lastMessage).toBe("payload") }) it("is idempotent", function (){ socket.connect() const conn = socket.conn socket.connect() expect(conn).toBe(socket.conn) }) }) describe("disconnect", function (){ let mockServer beforeAll(function (){ mockServer = new WebSocketServer("wss://example.com/") }) afterAll(function (done){ mockServer.stop(() => done()) }) beforeEach(function (){ socket = new Socket("/socket") }) it("removes existing connection", function (done){ socket.connect() socket.disconnect() socket.disconnect(() => { expect(socket.conn).toBeNull() done() }) }) it("calls callback", function (done){ let count = 0 socket.connect() socket.disconnect(() => { count++ expect(count).toBe(1) done() }) }) it("calls connection close callback", function (done){ socket.connect() const closeSpy = jest.spyOn(socket.conn, "close") socket.disconnect(() => { expect(closeSpy).toHaveBeenCalledWith(1000, "reason") done() }, 1000, "reason") }) it("does not throw when no connection", function (){ expect(() => { socket.disconnect() }).not.toThrow() }) it("properly tears down old connection when immediately reconnecting", function (){ const connections = [] const mockWebSocket = function StubWebSocketNoAutoClose(_url){ const conn = { readyState: SOCKET_STATES.open, get bufferedAmount(){ return 1 }, binaryType: "arraybuffer", timeout: 20000, onopen: null, onerror: null, onmessage: null, onclose: null, close(_code, _reason){ this.readyState = SOCKET_STATES.closing setTimeout(() => { this.readyState = SOCKET_STATES.closed }, 1000) }, send(){}, } connections.push(conn) return conn } jest.useFakeTimers() socket = new Socket("/socket", { heartbeatIntervalMs: 30000, heartbeatTimeoutMs: 30000, reconnectAfterMs: () => 10, transport: mockWebSocket }) socket.connect() const originalConn = socket.conn // Disconnect triggers teardown, which waits for bufferedAmount to be zero or 2250ms, // then awaits SOCKET_STATES.closed before calling the callback. const disconnected = jest.fn() socket.disconnect(disconnected) // For now, the conn is still set. expect(socket.conn).toBeTruthy() // Advance time by > 2250ms, which means we are waiting for socket to transition to closed jest.advanceTimersByTime(3000) // Now we call connect, while the teardown is still running socket.connect() // By now, waitForSocketClosed should be done, but now there's a new conn! jest.advanceTimersByTime(3000) expect(socket.conn).not.toBe(originalConn) const openConns = connections.filter(c => c.readyState === SOCKET_STATES.open) expect(openConns.length).toBe(1) // Late teardown must not overwrite this.conn with null when it is already connB expect(socket.conn).not.toBeNull() // the original disconnected should have been called expect(disconnected).toHaveBeenCalled() jest.useRealTimers() }) it("properly tears down old connection when disconnecting twice", function (){ const connections = [] const mockWebSocket = function StubWebSocketNoAutoClose(_url){ const conn = { readyState: SOCKET_STATES.open, get bufferedAmount(){ return 1 }, binaryType: "arraybuffer", timeout: 20000, onopen: null, onerror: null, onmessage: null, onclose: null, close(_code, _reason){ this.readyState = SOCKET_STATES.closing setTimeout(() => { this.readyState = SOCKET_STATES.closed }, 1000) }, send(){}, } connections.push(conn) return conn } jest.useFakeTimers() socket = new Socket("/socket", { heartbeatIntervalMs: 30000, heartbeatTimeoutMs: 30000, reconnectAfterMs: () => 10, transport: mockWebSocket }) socket.connect() const disconnected = jest.fn() socket.disconnect(disconnected) // For now, the conn is still set. expect(socket.conn).toBeTruthy() // Advance time by > 2250ms, which means we are waiting for socket to transition to closed jest.advanceTimersByTime(3000) // Now we call disconnect again, while the teardown is still running const disconnected2 = jest.fn() socket.disconnect(disconnected2) jest.advanceTimersByTime(10000) const openConns = connections.filter(c => c.readyState === SOCKET_STATES.open) expect(openConns.length).toBe(0) expect(socket.conn).toBeNull() // both disconnected functions should have been called expect(disconnected).toHaveBeenCalled() expect(disconnected2).toHaveBeenCalled() jest.useRealTimers() }) }) describe("connectionState", function (){ beforeEach(function (){ socket = new Socket("/socket") }) it("defaults to closed", function (){ expect(socket.connectionState()).toBe("closed") }) it("returns closed if readyState unrecognized", function (){ socket.connect() socket.conn.readyState = 5678 expect(socket.connectionState()).toBe("closed") }) it("returns connecting", function (){ socket.connect() socket.conn.readyState = 0 expect(socket.connectionState()).toBe("connecting") expect(socket.isConnected()).toBe(false) }) it("returns open", function (){ socket.connect() socket.conn.readyState = 1 expect(socket.connectionState()).toBe("open") expect(socket.isConnected()).toBe(true) }) it("returns closing", function (){ socket.connect() socket.conn.readyState = 2 expect(socket.connectionState()).toBe("closing") expect(socket.isConnected()).toBe(false) }) it("returns closed", function (){ socket.connect() socket.conn.readyState = 3 expect(socket.connectionState()).toBe("closed") expect(socket.isConnected()).toBe(false) }) }) describe("channel", function (){ let channel beforeEach(function (){ socket = new Socket("/socket") }) it("returns channel with given topic and params", function (){ channel = socket.channel("topic", {one: "two"}) expect(channel.socket).toBe(socket) expect(channel.topic).toBe("topic") expect(channel.params()).toEqual({one: "two"}) }) it("adds channel to sockets channels list", function (){ expect(socket.channels.length).toBe(0) channel = socket.channel("topic", {one: "two"}) expect(socket.channels.length).toBe(1) const [foundChannel] = socket.channels expect(foundChannel).toBe(channel) }) }) describe("remove", function (){ it("removes given channel from channels", function (){ socket = new Socket("/socket") const channel1 = socket.channel("topic-1") const channel2 = socket.channel("topic-2") jest.spyOn(channel1, "joinRef").mockReturnValue(1) jest.spyOn(channel2, "joinRef").mockReturnValue(2) expect(socket.stateChangeCallbacks.open.length).toBe(2) socket.remove(channel1) expect(socket.stateChangeCallbacks.open.length).toBe(1) expect(socket.channels.length).toBe(1) const [foundChannel] = socket.channels expect(foundChannel).toBe(channel2) }) }) describe("push", function (){ let data, json beforeEach(function (){ data = {topic: "topic", event: "event", payload: "payload", ref: "ref"} json = encode(data) socket = new Socket("/socket") }) it("sends data to connection when connected", function (){ socket.connect() socket.conn.readyState = 1 // open const sendSpy = jest.spyOn(socket.conn, "send") socket.push(data) expect(sendSpy).toHaveBeenCalledWith(json) }) it("buffers data when not connected", function (){ socket.connect() socket.conn.readyState = 0 // connecting const sendSpy = jest.spyOn(socket.conn, "send").mockImplementation(() => {}) expect(socket.sendBuffer.length).toBe(0) socket.push(data) expect(sendSpy).not.toHaveBeenCalledWith(json) expect(socket.sendBuffer.length).toBe(1) const [callback] = socket.sendBuffer callback() expect(sendSpy).toHaveBeenCalledWith(json) }) }) describe("makeRef", function (){ beforeEach(function (){ socket = new Socket("/socket") }) it("returns next message ref", function (){ expect(socket.ref).toBe(0) expect(socket.makeRef()).toBe("1") expect(socket.ref).toBe(1) expect(socket.makeRef()).toBe("2") expect(socket.ref).toBe(2) }) it("restarts for overflow", function (){ socket.ref = Number.MAX_SAFE_INTEGER + 1 expect(socket.makeRef()).toBe("0") expect(socket.ref).toBe(0) }) }) describe("sendHeartbeat", function (){ beforeEach(function (){ socket = new Socket("/socket") socket.connect() }) it("closes socket when heartbeat is not ack'd within heartbeat window", function (done){ jest.useFakeTimers() let closed = false socket.conn.readyState = 1 // open socket.conn.close = () => closed = true socket.sendHeartbeat() expect(closed).toBe(false) jest.advanceTimersByTime(10000) expect(closed).toBe(false) jest.advanceTimersByTime(20010) expect(closed).toBe(true) jest.useRealTimers() done() }) it("pushes heartbeat data when connected", function (){ socket.conn.readyState = 1 // open const sendSpy = jest.spyOn(socket.conn, "send") const data = "[null,\"1\",\"phoenix\",\"heartbeat\",{}]" socket.sendHeartbeat() expect(sendSpy).toHaveBeenCalledWith(data) }) it("no ops when not connected", function (){ socket.conn.readyState = 0 // connecting const sendSpy = jest.spyOn(socket.conn, "send") const data = encode({topic: "phoenix", event: "heartbeat", payload: {}, ref: "1"}) socket.sendHeartbeat() expect(sendSpy).not.toHaveBeenCalledWith(data) }) }) describe("flushSendBuffer", function (){ beforeEach(function (){ socket = new Socket("/socket") socket.connect() }) it("calls callbacks in buffer when connected", function (){ socket.conn.readyState = 1 // open const spy1 = jest.fn() const spy2 = jest.fn() socket.sendBuffer.push(spy1) socket.sendBuffer.push(spy2) socket.flushSendBuffer() expect(spy1).toHaveBeenCalledTimes(1) expect(spy2).toHaveBeenCalledTimes(1) }) it("empties sendBuffer", function (){ socket.conn.readyState = 1 // open socket.sendBuffer.push(() => { }) socket.flushSendBuffer() expect(socket.sendBuffer.length).toBe(0) }) }) describe("onConnOpen", function (){ let mockServer beforeAll(function (){ mockServer = new WebSocketServer("wss://example.com/") }) afterAll(function (done){ mockServer.stop(() => done()) }) beforeEach(function (){ socket = new Socket("/socket", { reconnectAfterMs: () => 100000 }) socket.connect() }) it("flushes the send buffer", function (){ socket.conn.readyState = 1 // open const spy = jest.fn() socket.sendBuffer.push(spy) socket.onConnOpen() expect(spy).toHaveBeenCalledTimes(1) }) it("resets reconnectTimer", function (){ const resetSpy = jest.spyOn(socket.reconnectTimer, "reset") socket.onConnOpen() expect(resetSpy).toHaveBeenCalledTimes(1) }) it("triggers onOpen callback", function (){ const spy = jest.fn() socket.onOpen(spy) socket.onConnOpen() expect(spy).toHaveBeenCalledTimes(1) }) }) describe("onConnClose", function (){ let mockServer beforeAll(function (){ mockServer = new WebSocketServer("wss://example.com/") }) afterAll(function (done){ mockServer.stop(() => done()) }) beforeEach(function (){ socket = new Socket("/socket", { reconnectAfterMs: () => 100000 }) socket.connect() }) it("does not schedule reconnectTimer if normal close", function (){ const scheduleSpy = jest.spyOn(socket.reconnectTimer, "scheduleTimeout") const event = {code: 1000} socket.onConnClose(event) expect(scheduleSpy).not.toHaveBeenCalled() }) it("schedules reconnectTimer timeout if abnormal close", function (){ const scheduleSpy = jest.spyOn(socket.reconnectTimer, "scheduleTimeout") const event = {code: 1006} socket.onConnClose(event) expect(scheduleSpy).toHaveBeenCalledTimes(1) }) it("does not schedule reconnectTimer timeout if normal close after explicit disconnect", function (){ const scheduleSpy = jest.spyOn(socket.reconnectTimer, "scheduleTimeout") socket.disconnect() expect(scheduleSpy).not.toHaveBeenCalled() }) it("schedules reconnectTimer timeout if not normal close", function (){ const scheduleSpy = jest.spyOn(socket.reconnectTimer, "scheduleTimeout") const event = {code: 1001} socket.onConnClose(event) expect(scheduleSpy).toHaveBeenCalledTimes(1) }) it("schedules reconnectTimer timeout if connection cannot be made after a previous clean disconnect", function (done){ const scheduleSpy = jest.spyOn(socket.reconnectTimer, "scheduleTimeout") socket.disconnect(() => { socket.connect() const event = {code: 1001} socket.onConnClose(event) expect(scheduleSpy).toHaveBeenCalledTimes(1) done() }) }) it("triggers onClose callback", function (){ const spy = jest.fn() socket.onClose(spy) socket.onConnClose("event") expect(spy).toHaveBeenCalledWith("event") }) it("triggers channel error if joining", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join() expect(channel.state).toBe("joining") socket.onConnClose() expect(triggerSpy).toHaveBeenCalledWith("phx_error") }) it("triggers channel error if joined", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join().trigger("ok", {}) expect(channel.state).toBe("joined") socket.onConnClose() expect(triggerSpy).toHaveBeenCalledWith("phx_error") }) it("does not trigger channel error after leave", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join().trigger("ok", {}) channel.leave() expect(channel.state).toBe("closed") socket.onConnClose() expect(triggerSpy).not.toHaveBeenCalledWith("phx_error") }) it("does not send heartbeat after explicit disconnect", function (done){ jest.useFakeTimers() const sendHeartbeatSpy = jest.spyOn(socket, "sendHeartbeat") socket.onConnOpen() socket.disconnect() jest.advanceTimersByTime(30000) expect(sendHeartbeatSpy).not.toHaveBeenCalled() jest.useRealTimers() done() }) it("does not timeout the heartbeat after explicit disconnect", function (done){ jest.useFakeTimers() const heartbeatTimeoutSpy = jest.spyOn(socket, "heartbeatTimeout") socket.onConnOpen() socket.disconnect() jest.advanceTimersByTime(60000) expect(heartbeatTimeoutSpy).not.toHaveBeenCalled() jest.useRealTimers() done() }) }) describe("onConnError", function (){ let mockServer beforeAll(function (){ mockServer = new WebSocketServer("wss://example.com/") }) afterAll(function (done){ mockServer.stop(() => done()) }) beforeEach(function (){ socket = new Socket("/socket", { reconnectAfterMs: () => 100000 }) socket.connect() }) it("triggers onClose callback", function (){ const spy = jest.fn() socket.onError(spy) socket.onConnError("error") expect(spy).toHaveBeenCalledWith("error", expect.any(Function), 0) }) it("triggers channel error if joining with open connection", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join() socket.onConnOpen() expect(channel.state).toBe("joining") socket.onConnError("error") expect(triggerSpy).toHaveBeenCalledWith("phx_error") }) it("triggers channel error if joining with no connection", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join() expect(channel.state).toBe("joining") socket.onConnError("error") expect(triggerSpy).toHaveBeenCalledWith("phx_error") }) it("triggers channel error if joined", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join().trigger("ok", {}) socket.onConnOpen() expect(channel.state).toBe("joined") let connectionsCount = null let transport = null socket.onError((error, erroredTransport, conns) => { transport = erroredTransport connectionsCount = conns }) socket.onConnError("error") expect(transport).toBe(WebSocket) expect(connectionsCount).toBe(1) expect(triggerSpy).toHaveBeenCalledWith("phx_error") }) it("does not trigger channel error after leave", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join().trigger("ok", {}) channel.leave() expect(channel.state).toBe("closed") socket.onConnError("error") expect(triggerSpy).not.toHaveBeenCalledWith("phx_error") }) it("does not trigger channel error if transport replaced with no previous connection", function (){ const channel = socket.channel("topic") const triggerSpy = jest.spyOn(channel, "trigger") channel.join() expect(channel.state).toBe("joining") let connectionsCount = null class FakeTransport { } socket.onError((error, transport, conns) => { socket.replaceTransport(FakeTransport) connectionsCount = conns }) socket.onConnError("error") expect(connectionsCount).toBe(0) expect(socket.transport).toBe(FakeTransport) expect(triggerSpy).not.toHaveBeenCalledWith("phx_error") }) }) describe("onConnMessage", function (){ let mockServer beforeAll(function (){ mockServer = new WebSocketServer("wss://example.com/") }) afterAll(function (done){ mockServer.stop(() => done()) }) beforeEach(function (){ socket = new Socket("/socket", { reconnectAfterMs: () => 100000 }) socket.connect() }) it("parses raw message and triggers channel event", function (){ const message = encode({topic: "topic", event: "event", payload: "payload", ref: "ref"}) const data = {data: message} const targetChannel = socket.channel("topic") const otherChannel = socket.channel("off-topic") const targetSpy = jest.spyOn(targetChannel, "trigger") const otherSpy = jest.spyOn(otherChannel, "trigger") socket.onConnMessage(data) expect(targetSpy).toHaveBeenCalledWith("event", "payload", "ref", null) expect(targetSpy).toHaveBeenCalledTimes(1) expect(otherSpy).toHaveBeenCalledTimes(0) }) it("triggers onMessage callback", function (){ const message = {"topic": "topic", "event": "event", "payload": "payload", "ref": "ref"} const spy = jest.fn() socket.onMessage(spy) socket.onConnMessage({data: encode(message)}) expect(spy).toHaveBeenCalledWith({ "topic": "topic", "event": "event", "payload": "payload", "ref": "ref", "join_ref": null }) }) }) describe("ping", function (){ beforeEach(function (){ socket = new Socket("/socket") socket.connect() }) it("pushes when connected", function (done){ let latency = 100 socket.conn.readyState = 1 // open expect(socket.isConnected()).toBe(true) socket.push = (msg) => { setTimeout(() => { socket.onConnMessage({data: encode({topic: "phoenix", event: "phx_reply", ref: msg.ref})}) }, latency) } const result = socket.ping(rtt => { // if we're unlucky we could also receive 99 as rtt, so let's be generous expect(rtt >= (latency - 10)).toBe(true) done() }) expect(result).toBe(true) }) it("returns false when disconnected", function (){ socket.conn.readyState = 0 expect(socket.isConnected()).toBe(false) const result = socket.ping(_rtt => true) expect(result).toBe(false) }) }) describe("custom encoder and decoder", function (){ it("encodes to JSON array by default", function (){ socket = new Socket("/socket") const payload = {topic: "topic", ref: "2", join_ref: "1", event: "join", payload: {foo: "bar"}} socket.encode(payload, encoded => { expect(encoded).toBe("[\"1\",\"2\",\"topic\",\"join\",{\"foo\":\"bar\"}]") }) }) it("allows custom encoding when using WebSocket transport", function (){ const encoder = (payload, callback) => callback("encode works") socket = new Socket("/socket", {transport: WebSocket, encode: encoder}) socket.encode({foo: "bar"}, encoded => { expect(encoded).toBe("encode works") }) }) it("forces JSON encoding when using LongPoll transport", function (){ const encoder = (payload, callback) => callback("encode works") socket = new Socket("/socket", {transport: LongPoll, encode: encoder}) const payload = {topic: "topic", ref: "2", join_ref: "1", event: "join", payload: {foo: "bar"}} socket.encode(payload, encoded => { expect(encoded).toBe("[\"1\",\"2\",\"topic\",\"join\",{\"foo\":\"bar\"}]") }) }) it("decodes JSON by default", function (){ socket = new Socket("/socket") const encoded = "[\"1\",\"2\",\"topic\",\"join\",{\"foo\":\"bar\"}]" socket.decode(encoded, decoded => { expect(decoded).toEqual({topic: "topic", ref: "2", join_ref: "1", event: "join", payload: {foo: "bar"}}) }) }) it("allows custom decoding when using WebSocket transport", function (){ const decoder = (payload, callback) => callback("decode works") socket = new Socket("/socket", {transport: WebSocket, decode: decoder}) socket.decode("...esoteric format...", decoded => { expect(decoded).toBe("decode works") }) }) it("forces JSON decoding when using LongPoll transport", function (){ const decoder = (payload, callback) => callback("decode works") socket = new Socket("/socket", {transport: LongPoll, decode: decoder}) const payload = {topic: "topic", ref: "2", join_ref: "1", event: "join", payload: {foo: "bar"}} socket.decode("[\"1\",\"2\",\"topic\",\"join\",{\"foo\":\"bar\"}]", decoded => { expect(decoded).toEqual(payload) }) }) }) }) window.XMLHttpRequest = jest.fn() window.WebSocket = WebSocket ================================================ FILE: babel.config.json ================================================ { "presets": [ "@babel/preset-env" ] } ================================================ FILE: config/config.exs ================================================ import Config config :logger, :console, colors: [enabled: false], format: "\n$time $metadata[$level] $message\n" config :phoenix, json_library: Jason, stacktrace_depth: 20, trim_on_html_eex_engine: false, sort_verified_routes_query_params: true if Mix.env() == :dev do esbuild = fn args -> [ args: ~w(./js/phoenix --bundle) ++ args, cd: Path.expand("../assets", __DIR__), env: %{"NODE_PATH" => Path.expand("../deps", __DIR__)} ] end config :esbuild, version: "0.25.4", module: esbuild.(~w(--format=esm --sourcemap --outfile=../priv/static/phoenix.mjs)), main: esbuild.(~w(--format=cjs --sourcemap --outfile=../priv/static/phoenix.cjs.js)), cdn: esbuild.( ~w(--target=es2016 --format=iife --global-name=Phoenix --outfile=../priv/static/phoenix.js) ), cdn_min: esbuild.( ~w(--target=es2016 --format=iife --global-name=Phoenix --minify --outfile=../priv/static/phoenix.min.js) ) end ================================================ FILE: eslint.config.mjs ================================================ import jest from "eslint-plugin-jest" import js from "@eslint/js" import stylistic from "@stylistic/eslint-plugin" export default [ { // eslint config is very unintuitive; they will match an js file in any // directory by default and you can only expand this; // moreover, to have a global ignore, it must be specified without // any other key as a separate object... ignores: [ "integration_test/", "installer/", "doc/", "deps/", "coverage/", "priv/", "tmp/", "test/" ], }, { ...js.configs.recommended, plugins: { jest, "@stylistic": stylistic }, languageOptions: { globals: { ...jest.environments.globals.globals, global: "writable", }, ecmaVersion: 12, sourceType: "module", }, rules: { "@stylistic/indent": ["error", 2, { SwitchCase: 1, }], "@stylistic/linebreak-style": ["error", "unix"], "@stylistic/quotes": ["error", "double"], "@stylistic/semi": ["error", "never"], "@stylistic/object-curly-spacing": ["error", "never", { objectsInObjects: false, arraysInObjects: false, }], "@stylistic/array-bracket-spacing": ["error", "never"], "@stylistic/comma-spacing": ["error", { before: false, after: true, }], "@stylistic/computed-property-spacing": ["error", "never"], "@stylistic/space-before-blocks": ["error", { functions: "never", keywords: "never", classes: "always", }], "@stylistic/keyword-spacing": ["error", { overrides: { if: { after: false, }, for: { after: false, }, while: { after: false, }, switch: { after: false, }, }, }], "@stylistic/eol-last": ["error", "always"], "no-unused-vars": ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_", }], "no-useless-escape": "off", "no-cond-assign": "off", "no-case-declarations": "off", }, }] ================================================ FILE: guides/asset_management.md ================================================ # Asset Management Beside producing HTML, most web applications have various assets (JavaScript, CSS, images, fonts and so on). From Phoenix v1.7, new applications use [esbuild](https://esbuild.github.io/) to prepare assets via the [Elixir esbuild wrapper](https://github.com/phoenixframework/esbuild), and [tailwindcss](https://tailwindcss.com) via the [Elixir tailwindcss wrapper](https://github.com/phoenixframework/tailwind) for CSS. The direct integration with `esbuild` and `tailwind` means that newly generated applications do not have dependencies on Node.js or an external build system (e.g. Webpack). Your JavaScript is typically placed at "assets/js/app.js" and `esbuild` will extract it to "priv/static/assets/js/app.js". In development, this is done automatically via the `esbuild` watcher. In production, this is done by running `mix assets.deploy`. `esbuild` can also handle your CSS files, but by default `tailwind` handles all CSS building. Finally, all other assets, that usually don't have to be preprocessed, go directly to "priv/static". ## Third-party JS packages If you want to import JavaScript dependencies, you have at least three options to add them to your application: 1. Vendor those dependencies inside your project and import them in your "assets/js/app.js" using a relative path: ```javascript import topbar from "../vendor/topbar" ``` 2. Call `npm install topbar --prefix assets`, which will create `package.json` and `package-lock.json` inside your assets directory, and `esbuild` will be able to automatically pick them up: ```javascript import topbar from "topbar" ``` To ensure that `npm install` is being run when checking out your project, or when building a release, add a `"cmd --cd assets npm ci"` step in `mix.exs` to the `assets.deploy` and `assets.build` steps: ```elixir "assets.build": ["cmd --cd assets npm ci", "tailwind your_app", "esbuild your_app"], "assets.deploy": [ "cmd --cd assets npm ci", "tailwind your_app --minify", "esbuild your_app --minify", "phx.digest" ] ``` 3. Use Mix to track the dependency from a source repository: ```elixir # mix.exs {:topbar, github: "buunguyen/topbar", app: false, compile: false} ``` Run `mix deps.get` to fetch the dependency and then import it: ```javascript import topbar from "topbar" ``` New applications use this third approach to import icons, such as Heroicons, to avoid vendoring a copy of all icons and to avoid additional system dependencies such as `npm`, while you can still track explicit versions thanks to Mix. It is important to note that git dependencies cannot be used by Hex packages, so if you intend to publish your project to Hex, consider alternatives approaches. Note that if you use third party JS package managers, you might need to adjust your deployment steps to properly include the packages. If you're using `mix phx.gen.release --docker`, have a look at the [documentation](Mix.Tasks.Phx.Gen.Release.html#module-docker) for further details. ## Images, fonts, and external files If you reference an external file in your CSS or JavaScript files, `esbuild` will attempt to validate and manage them, unless told otherwise. For example, imagine you want to reference `priv/static/images/bg.png`, served at `/images/bg.png`, from your CSS file: ```css body { background-image: url(/images/bg.png); } ``` The above may fail with the following message: ```text error: Could not resolve "/images/bg.png" (mark it as external to exclude it from the bundle) ``` Given the images are already managed by Phoenix, you need to mark all resources from `/images` (and also `/fonts`) as external, as the error message says. This is what Phoenix does by default for new apps since v1.6.1+. In your `config/config.exs`, you will find: ```elixir args: ~w(js/app.js --bundle --target=es2022 --outdir=../priv/static/assets/js --external:/fonts/* --external:/images/*), ``` If you need to reference other directories, you need to update the arguments above accordingly. Note running `mix phx.digest` will create digested files for all of the assets in `priv/static`, so your images and fonts are still cache-busted. ### Ensuring fonts and images from third-party libraries are loaded If you import a Node package that depends on additional fonts or images, you might find them to fail to load. This is because they are referenced in the JS or CSS but by default Esbuild will not touch or process referenced files. You can add arguments to esbuild in `config/config.exs` to ensure that the referenced resources are copied to the output folder. The following example would copy all referenced font files to the output folder and prefix the paths with `/assets/`: ```elixir args: ~w(js/app.js --bundle --target=es2017 --outdir=../priv/static/assets --external:/fonts/* --external:/images/* --public-path=/assets/ --loader:.woff=copy --loader:.ttf=copy --loader:.eot=copy --loader:.woff2=copy), ``` For more information, see [the esbuild documentation](https://esbuild.github.io/content-types/#copy). ## Esbuild plugins Phoenix's default configuration of `esbuild` (via the Elixir wrapper) does not allow you to use [esbuild plugins](https://esbuild.github.io/plugins/). If you want to use an esbuild plugin, for example to compile SASS files to CSS, you can replace the default build system with a custom build script. The following is an example of a custom build using esbuild via Node.js. First of all, you'll need to install Node.js in development and make it available for your production build step. Then you'll need to add `esbuild` to your Node.js packages and the Phoenix packages. Inside the `assets` directory, run: ```console $ npm install esbuild --save-dev $ npm install ../deps/phoenix ../deps/phoenix_html ../deps/phoenix_live_view --save ``` or, for Yarn: ```console $ yarn add --dev esbuild $ yarn add ../deps/phoenix ../deps/phoenix_html ../deps/phoenix_live_view ``` Next, add a custom JavaScript build script. We'll call the example `assets/build.js`: ```javascript const esbuild = require("esbuild"); const args = process.argv.slice(2); const watch = args.includes('--watch'); const deploy = args.includes('--deploy'); const loader = { // Add loaders for images/fonts/etc, e.g. { '.svg': 'file' } }; const plugins = [ // Add and configure plugins here ]; // Define esbuild options let opts = { entryPoints: ["js/app.js"], bundle: true, logLevel: "info", target: "es2022", outdir: "../priv/static/assets", external: ["*.css", "fonts/*", "images/*"], nodePaths: ["../deps"], loader: loader, plugins: plugins, }; if (deploy) { opts = { ...opts, minify: true, }; } if (watch) { opts = { ...opts, sourcemap: "inline", }; esbuild .context(opts) .then((ctx) => { ctx.watch(); }) .catch((_error) => { process.exit(1); }); } else { esbuild.build(opts); } ``` This script covers following use cases: - `node build.js`: builds for development & testing (useful on CI) - `node build.js --watch`: like above, but watches for changes continuously - `node build.js --deploy`: builds minified assets for production Modify `config/dev.exs` so that the script runs whenever you change files, replacing the existing `:esbuild` configuration under `watchers`: ```elixir config :hello, HelloWeb.Endpoint, ... watchers: [ node: ["build.js", "--watch", cd: Path.expand("../assets", __DIR__)] ], ... ``` Modify the `aliases` task in `mix.exs` to install `npm` packages during `mix setup` and use the new `esbuild` on `mix assets.deploy`: ```elixir defp aliases do [ setup: ["deps.get", "ecto.setup", "cmd --cd assets npm install"], ..., "assets.deploy": ["cmd --cd assets node build.js --deploy", "phx.digest"] ] end ``` Finally, remove the `esbuild` configuration from `config/config.exs` and remove the dependency from the `deps` function in your `mix.exs`, and you are done! ## Alternative JS build tools If you are writing an API or you want to use another asset build tool, you may want to remove the `esbuild` Hex package (see steps below). Then you must follow the additional steps required by the third-party tool. ### Remove esbuild 1. Remove the `esbuild` configuration in `config/config.exs` and `config/dev.exs`, 2. Remove the `assets.deploy` task defined in `mix.exs`, 3. Remove the `esbuild` dependency from `mix.exs`, 4. Unlock the `esbuild` dependency: ```console $ mix deps.unlock esbuild ``` ## Alternative CSS frameworks By default, Phoenix generates CSS with the `tailwind` library and its default plugins. If you want to use external `tailwind` plugins or another CSS framework, you should replace the `tailwind` Hex package (see steps below). Then you can use an `esbuild` plugin (as outlined above) or even bring a separate framework altogether. ### Remove tailwind 1. Remove the `tailwind` configuration in `config/config.exs` and `config/dev.exs`, 2. Remove the `assets.deploy` task defined in `mix.exs`, 3. Remove the `tailwind` dependency from `mix.exs`, 4. Unlock the `tailwind` dependency: ```console $ mix deps.unlock tailwind ``` You may optionally remove and delete the `heroicons` dependency as well. ## Alternative icon libraries Phoenix ships with the [Heroicons](https://heroicons.com/) library for icons support. This is done by embedding icons as CSS classes, which guarantees only the icons actually used by your application are sent to the client, thanks to Tailwind. If you prefer to use an alternative icon set, it should be possible to adapt the code that embeds Heroicons to use another library. Let's see exactly how to do that using [Remix Icon](https://remixicon.com/) as an example: First replace the `heroicon` repository in your `mix.exs` by `remixicons`: ```elixir {:remixicons, github: "Remix-Design/RemixIcon", sparse: "icons", tag: "v4.6.0", app: false, compile: false, depth: 1}, ``` Then replace `assets/vendor/heroicons.js`, which traverses the heroicons dependency, by `assets/vendor/remixicons.js`, which traverses remix icons instead: ```js const plugin = require("tailwindcss/plugin") const fs = require("fs") const path = require("path") module.exports = plugin(function({matchComponents, theme}) { let baseDir = path.join(__dirname, "../../deps/remixicons/icons"); let values = {}; let icons = fs .readdirSync(baseDir, { withFileTypes: true }) .filter((dirent) => dirent.isDirectory()) .map((dirent) => dirent.name); icons.forEach((dir) => { fs.readdirSync(path.join(baseDir, dir)).map((file) => { let name = path.basename(file, ".svg"); values[name] = { name, fullPath: path.join(baseDir, dir, file) }; }); }); matchComponents( { ri: ({ name, fullPath }) => { let content = fs .readFileSync(fullPath) .toString() .replace(/\r?\n|\r/g, ""); return { [`--ri-${name}`]: `url('data:image/svg+xml;utf8,${content}')`, "-webkit-mask": `var(--ri-${name})`, mask: `var(--ri-${name})`, "background-color": "currentColor", "vertical-align": "middle", display: "inline-block", width: theme("spacing.10"), height: theme("spacing.10"), }; }, }, { values }, ); }) ``` And then change `assets/css/app.css` to import your new plugin instead. Finally, update the `icon` function in `lib/my_app_web/components/core_components.ex` to match on `ri-` prefixes instead: ``` @doc """ Renders a [Remix Icon](https://remixicon.com). You can customize the size and colors of the icons by setting width, height, and background color classes. ## Examples <.icon name="ri-github-fill" /> <.icon name="ri-github" class="ml-1 w-3 h-3 animate-spin" /> """ attr :name, :string, required: true attr :class, :any, default: "size-5" def icon(%{name: "ri-" <> _} = assigns) do ~H""" """ end ``` Now replace the Heroicons in your application by Remix ones and you are good to go! The approach above may also work with other libraries, it is a matter of adapting the Tailwind plugin to traverse these libraries and generate the proper classes. Some iconsets may also be available as regular Hex packages too. ================================================ FILE: guides/authn_authz/api_authentication.md ================================================ # API Authentication > **Requirement**: This guide expects that you have gone through the [`mix phx.gen.auth`](mix_phx_gen_auth.html) guide. This guide shows how to add API authentication on top of `mix phx.gen.auth`. Since the authentication generator already includes a token table, we use it to store API tokens too, following the best security practices. We will break this guide in two parts: augmenting the context and the plug implementation. We will assume that the following `mix phx.gen.auth` command was executed: ``` $ mix phx.gen.auth Accounts User users ``` If you ran something else, it should be trivial to adapt the names. ## Adding API functions to the context Our authentication system will require two functions. One to create the API token and another to verify it. Open up `lib/my_app/accounts.ex` and add these two new functions: ```elixir ## API @doc """ Creates a new api token for a user. The token returned must be saved somewhere safe. This token cannot be recovered from the database. """ def create_user_api_token(user) do {encoded_token, user_token} = UserToken.build_email_token(user, "api-token") Repo.insert!(user_token) encoded_token end @doc """ Fetches the user by API token. """ def fetch_user_by_api_token(token) do with {:ok, query} <- UserToken.verify_api_token_query(token), %User{} = user <- Repo.one(query) do {:ok, user} else _ -> :error end end ``` The new functions use the existing `UserToken` functionality to store a new type of token called "api-token". Because this is an email token, if the user changes their email, the tokens will be expired. Also notice we called the second function `fetch_user_by_api_token`, instead of `get_user_by_api_token`. Because we want to render different status codes in our API, depending if a user was found or not, we return `{:ok, user}` or `:error`. Elixir's convention is to call these functions `fetch_*`, instead of `get_*` which would usually return `nil` instead of tuples. To make sure our new functions work, let's write tests. Open up `test/my_app/accounts_test.exs` and add this new describe block: ```elixir describe "create_user_api_token/1 and fetch_user_by_api_token/1" do test "creates and fetches by token" do user = user_fixture() token = Accounts.create_user_api_token(user) assert Accounts.fetch_user_by_api_token(token) == {:ok, user} assert Accounts.fetch_user_by_api_token("invalid") == :error end end ``` If you run the tests, they will actually fail. Something similar to this: ```console 1) test create_user_api_token/1 and fetch_user_by_api_token/1 creates and fetches by token (Demo.AccountsTest) test/demo/accounts_test.exs:380 ** (UndefinedFunctionError) function Demo.Accounts.UserToken.verify_api_token_query/1 is undefined or private. Did you mean: * verify_change_email_token_query/2 * verify_magic_link_token_query/1 * verify_session_token_query/1 code: assert Accounts.fetch_user_by_api_token(token) == {:ok, user} stacktrace: (demo 0.1.0) Demo.Accounts.UserToken.verify_api_token_query("sTpJg7rt-KQ9gZ7xLMtn2keusGk9N2JpPwkXDx7LmHU") (demo 0.1.0) lib/demo/accounts.ex:325: Demo.Accounts.fetch_user_by_api_token/1 test/demo/accounts_test.exs:383: (test) ``` If you prefer, try looking at the error and fixing it yourself. The explanation will come next. The `UserToken` module contains functions for verifying different tokens. Right now, there is no `verify_api_token_query/1`, but we can implement it similar to the existing functions. How long the API token should be valid is going to depend on your application and how sensitive it is in terms of security. For this example, let's say the token is valid for 365 days. Open up `lib/my_app/accounts/user_token.ex`, and add a new function, like this: ```elixir @doc """ Checks if the API token is valid and returns its underlying lookup query. The query returns the user found by the token, if any. The given token is valid if it matches its hashed counterpart in the database and the user email has not changed. This function also checks if the token is being used within 365 days. """ def verify_api_token_query(token) do case Base.url_decode64(token, padding: false) do {:ok, decoded_token} -> hashed_token = :crypto.hash(@hash_algorithm, decoded_token) query = from token in by_token_and_context_query(hashed_token, "api-token"), join: user in assoc(token, :user), where: token.inserted_at > ago(^@api_token_validity_in_days, "day") and token.sent_to == user.email, select: user {:ok, query} :error -> :error end end ``` Note that we also added a `@api_token_validity_in_days` module attribute at the top of the file: ```diff @magic_link_validity_in_minutes 15 @change_email_validity_in_days 7 @session_validity_in_days 60 + @api_token_validity_in_days 365 ``` Now tests should pass and we are ready to move forward! ## API authentication plug The last part is to add authentication to our API. When we ran `mix phx.gen.auth`, it generated a `MyAppWeb.UserAuth` module with several plugs, which are small functions that receive the `conn` and customize our request/response life-cycle. Open up `lib/my_app_web/user_auth.ex` and add this new function: ```elixir def fetch_current_scope_for_api_user(conn, _opts) do with [<>] <- get_req_header(conn, "authorization"), true <- String.downcase(bearer) == "bearer", {:ok, user} <- Accounts.fetch_user_by_api_token(token) do assign(conn, :current_scope, Scope.for_user(user)) else _ -> conn |> send_resp(:unauthorized, "No access for you") |> halt() end end ``` Our function receives the connection and checks if the "authorization" header has been set with "Bearer TOKEN", where "TOKEN" is the value returned by `Accounts.create_user_api_token/1`. In case the token is not valid or there is no such user, we abort the request. Finally, we need to add this `plug` to our pipeline. Open up `lib/my_app_web/router.ex` and you will find a pipeline for API. Let's add our new plug under it, like this: ```elixir pipeline :api do plug :accepts, ["json"] plug :fetch_current_scope_for_api_user end ``` Now you are ready to receive and validate API requests. Feel free to open up `test/my_app_web/user_auth_test.exs` and write your own test. You can use the tests for other plugs as templates! ## Your turn The overall API authentication flow will depend on your application. If you want to use this token in a JavaScript client, you will need to slightly alter the `UserSessionController` to invoke `Accounts.create_user_api_token/1` and return a JSON response including the token. If you want to provide APIs for 3rd-party users, you will need to allow them to create tokens, and show the result of `Accounts.create_user_api_token/1` to them. They must save these tokens somewhere safe and include them as part of their requests using the "authorization" header. ================================================ FILE: guides/authn_authz/authn_authz.md ================================================ # Introduction to Auth Authentication (authn) and authorization (authz) are two important concepts in security. Authentication is the process of verifying the identity of a user or system, while authorization is the process of granting or denying access to resources based on the user's identity and permissions. Phoenix comes with built-in support for both. Generally speaking, developers use the `mix phx.gen.auth` generator to scaffold their authn and authz. Third-party libraries such as [Ueberauth](https://github.com/ueberauth/ueberauth) can be used either as complementary systems or by itself. Overall we have the following guides: * [mix phx.gen.auth](mix_phx_gen_auth.md) - An introduction to the `mix phx.gen.auth` generator and its security considerations. * [Scopes](scopes.md) - Scopes are the mechanism Phoenix v1.8 introduced to manage access to resources based on the user's identity and permissions. * [API Authentication](api_authentication.md) - An additional guide that shows how to expand `mix phx.gen.auth` code to support token-based API authentication. ================================================ FILE: guides/authn_authz/mix_phx_gen_auth.md ================================================ # mix phx.gen.auth The `mix phx.gen.auth` command generates a flexible, pre-built authentication system into your Phoenix app. This generator allows you to quickly move past the task of adding authentication to your codebase and stay focused on the real-world problem your application is trying to solve. It supports the following features: - User registration with account confirmation by email - Log in with magic links - Opt-in password authentication - "Sudo mode", also known as privileged authentication, where the user must confirm their identity before performing sensitive actions ## Getting started > Before running this command, consider committing your work as it generates multiple files. Let's start by running the following command from the root of our app: ```console $ mix phx.gen.auth Accounts User users An authentication system can be created in two different ways: - Using Phoenix.LiveView (default) - Using Phoenix.Controller only Do you want to create a LiveView based authentication system? [Y/n] Y ``` The first argument is the context module followed by the schema module and its plural name (used as the schema table name). The example above will generate an `Accounts` context module with two schemas inside: `User` and `UserToken`. The context module helps us group all of the different schemas related to authentication. You may name the context and schema according to your preferences. The authentication generators support Phoenix LiveView, for enhanced UX, so you should answer `Y` here. You may also answer `n` for a controller based authentication system. Either approach will create the same context and schemas, using the same table names and route paths. Since this generator installed additional dependencies in `mix.exs`, let's fetch those: ```console $ mix deps.get ``` Now run the pending repository migrations: ```console $ mix ecto.migrate ``` Let's run the tests to make sure our new authentication system works as expected. ```console $ mix test ``` And finally, let's start our Phoenix server and try it out (note the new `Register` and `Log in` links at the top right of the default page). ```console $ mix phx.server ``` ## Developer responsibilities Since Phoenix generates this code into your application instead of building these modules into Phoenix itself, you now have complete freedom to modify the authentication system, so it works best with your use case. The one caveat with using a generated authentication system is it will not be updated after it's been generated. Therefore, as improvements are made to the output of `mix phx.gen.auth`, it becomes your responsibility to determine if these changes need to be ported into your application. Security-related and other important improvements will be explicitly and clearly marked in the `CHANGELOG.md` file and upgrade notes. ## Generated code The following are notes about the generated authentication system. ### Forbidding access The generated code ships with an authentication module with a handful of plugs that fetch the current user, require authentication and so on. For instance, in an app named MyApp which had `mix phx.gen.auth Accounts User users` run on it, you will find a module named `MyAppWeb.UserAuth` with plugs such as: * `fetch_current_scope_for_user` - fetches the current user information if available and stores it as `:current_scope` assign * `require_authenticated_user` - must be invoked after `fetch_current_scope_for_user` and requires that a current user exists and is authenticated * `redirect_if_user_is_authenticated` - used for the few pages that must not be available to authenticated users (only generated for controller based authentication) * `require_sudo_mode` - used for pages that contain sensitive operations and enforces recent authentication ### Scopes The generated code includes a scope module. For an app named MyApp which had `mix phx.gen.auth Accounts User users` run on it, you will find the following module at `lib/my_app/accounts/scope.ex`: ```elixir defmodule MyApp.Accounts.Scope do # ... alias MyApp.Accounts.User defstruct user: nil @doc """ Creates a scope for the given user. Returns nil if no user is given. """ def for_user(%User{} = user) do %__MODULE__{user: user} end def for_user(nil), do: nil end ``` The scope data structure is stored in the assigns and available to your Controllers and LiveViews. As your application grows in complexity, this data structure can store important metadata such as the teams, companies, or organizations the user belongs to, permissions, telemetry information such as IP address and so forth. Furthermore, future Phoenix generator invocations will automatically pass this data structure from your Controllers and LiveViews to most of [your context operations](contexts.md), making sure that future data is scoped to the current user/team/company/organization. Scopes are essential to enforce the user can only access data they own. You can learn more about them in the [Scopes](scopes.md) guide. ### Password hashing The password hashing mechanism defaults to `bcrypt` for Unix systems and `pbkdf2` for Windows systems. Both systems use the [Comeonin interface](https://hexdocs.pm/comeonin/). The password hashing mechanism can be overridden with the `--hashing-lib` option. The following values are supported: * `bcrypt` - [bcrypt_elixir](https://hex.pm/packages/bcrypt_elixir) * `pbkdf2` - [pbkdf2_elixir](https://hex.pm/packages/pbkdf2_elixir) * `argon2` - [argon2_elixir](https://hex.pm/packages/argon2_elixir) We recommend developers to consider using `argon2`, which is the most robust of all 3. The downside is that `argon2` is quite CPU and memory intensive, and you will need more powerful instances to run your applications on. For more information about choosing these libraries, see the [Comeonin project](https://github.com/riverrun/comeonin). There are similar `:on_mount` hooks for LiveView based authentication. ### Notifiers The generated code is not integrated with any system to send SMSes or emails for confirming accounts, resetting passwords, etc. Instead, it simply logs a message to the terminal. It is your responsibility to integrate with the proper system after generation. Note that if you generated your Phoenix project with `mix phx.new`, your project is configured to use [Swoosh](https://hexdocs.pm/swoosh/Swoosh.html) mailer by default. To view notifier emails during development with Swoosh, navigate to `/dev/mailbox`. ### Concurrent tests The generated tests run concurrently if you are using a database that supports concurrent tests, which is the case of PostgreSQL. ### More about `mix phx.gen.auth` Check out `mix phx.gen.auth` for more details, such as using a different password hashing library, customizing the web module namespace, generating binary id type, configuring the default options, and using custom table names. ## Security considerations ### Tracking sessions All sessions and tokens are tracked in a separate table. This allows you to track how many sessions are active for each account. You could even expose this information to users if desired. Note that whenever the password changes (either via reset password or directly), all tokens are deleted, and the user has to log in again on all devices. ### User Enumeration attacks A user enumeration attack allows someone to check if an email is registered in the application. The generated authentication code does not attempt to protect from such attacks. For instance, when you register an account, if the email is already registered, the code will notify the user the email is already registered. If your application is sensitive to enumeration attacks, you need to implement your own workflows, which tends to be very different from most applications, as you need to carefully balance security and user experience. Furthermore, if you are concerned about enumeration attacks, beware of timing attacks too. For example, registering a new account typically involves additional work (such as writing to the database, sending emails, etc) compared to when an account already exists. Someone could measure the time taken to execute those additional tasks to enumerate emails. This applies to all endpoints (registration, login, etc.) that may send email, in-app notifications, etc. ### Confirmation and credential pre-stuffing attacks The generated functionality ships with an account confirmation mechanism, where users have to confirm their account, typically by email. Furthermore, to prevent security issues, the generated code does forbid users from using the application if their accounts have not yet been confirmed. If you want to change this behavior, please refer to the ["Mixing magic link and password registration" section](Mix.Tasks.Phx.Gen.Auth.html#module-mixing-magic-link-and-password-registration) of `mix phx.gen.auth`. ### Case sensitiveness The email lookup is made to be case-insensitive. Case-insensitive lookups are the default in MySQL and MSSQL. In SQLite3 we use [`COLLATE NOCASE`](https://www.sqlite.org/datatype3.html#collating_sequences) in the column definition to support it. In PostgreSQL, we use the [`citext` extension](https://www.postgresql.org/docs/current/citext.html). Note `citext` is part of PostgreSQL itself and is bundled with it in most operating systems and package managers. `mix phx.gen.auth` takes care of creating the extension and no extra work is necessary in the majority of cases. If by any chance your package manager splits `citext` into a separate package, you will get an error while migrating, and you can most likely solve it by installing the `postgres-contrib` package. ## Additional resources ### Migrating to Phoenix v1.8 magic links and sudo mode Phoenix v1.8 added new features and simplified the authentication code. Developers are not required to migrate to the new generators, although we recommend setting up your own scope, as defined in the [Scopes](scopes.md) guide. If you generated your authentication code with `mix phx.gen.auth` in Phoenix v1.7 or earlier and you want to migrate to the new generators, you can use the following pull requests as reference: * [Pull request for migrating LiveView based Phoenix 1.7 `phx.gen.auth` to magic links](https://github.com/SteffenDE/phoenix_gen_auth_magic_link/pull/1) * [Pull request for migrating controller based Phoenix 1.7 `phx.gen.auth` to magic links](https://github.com/SteffenDE/phoenix_gen_auth_magic_link/pull/2) Keep in mind that the new authentication system fully removes registering an account with password, which simplifies both the user experience and the generated code. Therefore, when migrating, you should not change your existing migration files, instead, you must make the `hashed_password` column optional by setting `null: true`. Also, when migrating to the new system and removing features like "Forgot your password?", you must set the `hashed_password` of all accounts that have not been confirmed to `nil`, after making the column nullable, to avoid credential stuffing attacks. For this reason, we recommend deploying the migrated authentication system during low-traffic periods, where ideally no user who has just registered an account would have their password nullified. If those trade-offs are not acceptable, [you can add magic links on top of your existing authentication system without a complete migration, as discussed here](https://github.com/srcrip/phoenix-magic-links). ### Initial implementation The following links describe the original implementation of the authentication system, the default up to Phoenix v1.7: * José Valim's blog post - [An upcoming authentication solution for Phoenix](https://dashbit.co/blog/a-new-authentication-solution-for-phoenix) * Berenice Medel's blog post on generating LiveViews for authentication (rather than conventional Controllers & Views) - [Bringing Phoenix Authentication to Life](https://fly.io/phoenix-files/phx-gen-auth/) * [Original design spec](https://github.com/dashbitco/mix_phx_gen_auth_demo/blob/auth/README.md) * [Pull request on bare Phoenix app](https://github.com/dashbitco/mix_phx_gen_auth_demo/pull/1) ================================================ FILE: guides/authn_authz/scopes.md ================================================ # Scopes A scope is a data structure used to keep information about the current request or session, such as the current user, the user's organization/company, permissions, and so on. Think of a scope as a container with information required by the majority of pages in your application. A scope can also hold request metadata, such as IP addresses. Scopes play an important role in security. [OWASP](https://owasp.org/) lists "Broken access control" as a [top-10 security risk](https://owasp.org/Top10/). Most application data is private for a user, a team, or an organization. Your database CRUD operations must be properly scoped to the current user/team/organization. Phoenix generators such as `mix phx.gen.html`, `mix phx.gen.json`, and `mix phx.gen.live` automatically use your custom scopes. Scopes are flexible. You can have more than one scope in your application and choose the specific scope when invoking a generator. When you run `mix phx.gen.auth`, it will automatically generate a scope for you, but you may also add your own. This guide will: * Show how `mix phx.gen.auth` generates a scope for you * Discuss how generators, such as `mix phx.gen.context`, rely on scopes for security * How to define your own scope from scratch and all valid options * Augment the built-in scope with additional scopes ## phx.gen.auth The task `mix phx.gen.auth` will generate a default scope. This scope ties the generated resources to the currently authenticated user. Let's see it in action: ```console $ mix phx.gen.auth Accounts User users ``` The scope code is the same for the `--live` and `--no-live` variants of the generator. Looking at the generated scope file `lib/my_app/accounts/scope.ex`, we can see that it defines a struct with a single `user` field, and a function `for_user/1` that, if given a `User` struct, returns a new `%Scope{}` for that user. ```elixir defmodule MyApp.Accounts.Scope do alias MyApp.Accounts.User defstruct user: nil def for_user(%User{} = user) do %__MODULE__{user: user} end def for_user(nil), do: nil end ``` The scope is automatically fetched by the `fetch_current_scope_for_user` plug that is injected into the `:browser` pipeline: ```elixir # router.ex ... pipeline :browser do ... plug :fetch_current_scope_for_user end ``` ```elixir # user_auth.ex def fetch_current_scope_for_user(conn, _opts) do {user_token, conn} = ensure_user_token(conn) user = user_token && Accounts.get_user_by_session_token(user_token) assign(conn, :current_scope, Scope.for_user(user)) end ``` Similarly, for LiveViews, there is a pre-defined `mount_current_scope` hook that ensures the scope is available: ```elixir # user_auth.ex def on_mount(:mount_current_scope, _params, session, socket) do {:cont, mount_current_scope(socket, session)} end defp mount_current_scope(socket, session) do Phoenix.Component.assign_new(socket, :current_scope, fn -> user = if user_token = session["user_token"] do Accounts.get_user_by_session_token(user_token) end Scope.for_user(user) end) end ``` ## Integration of scopes in the Phoenix generators If a default scope is defined in your application's config, the generators will build scoped resources by default. The generated LiveViews / Controllers will automatically pass the scope to the context functions. `mix phx.gen.auth` automatically sets its scope as default, if there is not already a default scope defined: ```elixir # config/config.exs config :my_app, :scopes, user: [ default: true, ... ] ``` We will look at the individual options in the next section. Now let's look at the code generated once a default scope is set. We will use `mix phx.gen.live` as an example, but the ideas and the overall code will be similar to `mix phx.gen.html` and `mix phx.gen.json` too: ```console $ mix phx.gen.live Blog Post posts title:string body:text ``` This creates a new `Blog` context, with a `Post` resource. To ensure the scope is available, for LiveViews the routes in your `router.ex` must be added to a `live_session` that ensures the user is authenticated. In this case, within the aptly named `required_authenticated_user` section: ```diff scope "/", MyAppWeb do pipe_through [:browser, :require_authenticated_user] live_session :require_authenticated_user, on_mount: [{MyAppWeb.UserAuth, :ensure_authenticated}] do live "/users/settings", UserLive.Settings, :edit live "/users/settings/confirm-email/:token", UserLive.Settings, :confirm_email + live "/posts", PostLive.Index, :index + live "/posts/new", PostLive.Form, :new + live "/posts/:id", PostLive.Show, :show + live "/posts/:id/edit", PostLive.Form, :edit end post "/users/update-password", UserSessionController, :update_password end ``` > Although the router has a `scope` macro, the router `scope` and `current_scope` are ultimately distinct features which have similar purposes: to narrow down access to parts of our application, each acting at distinct layers (one at the router, the other at the data layer). Now, let's look at the generated LiveView (`lib/my_app_web/live/post_live/index.ex`): ```elixir defmodule MyAppWeb.PostLive.Index do use MyAppWeb, :live_view alias MyApp.Blog ... @impl true def mount(_params, _session, socket) do Blog.subscribe_posts(socket.assigns.current_scope) {:ok, socket |> assign(:page_title, "Listing Posts") |> stream(:posts, Blog.list_posts(socket.assigns.current_scope))} end @impl true def handle_event("delete", %{"id" => id}, socket) do post = Blog.get_post!(socket.assigns.current_scope, id) {:ok, _} = Blog.delete_post(socket.assigns.current_scope, post) {:noreply, stream_delete(socket, :posts, post)} end @impl true def handle_info({type, %MyApp.Blog.Post{}}, socket) when type in [:created, :updated, :deleted] do {:noreply, stream(socket, :posts, Blog.list_posts(socket.assigns.current_scope), reset: true)} end end ``` Note that every function from the `Blog` context that we call gets the `current_scope` assign passed in as the first argument. The `list_posts/1` function then uses that information to properly filter posts: ```elixir # lib/my_app/blog.ex def list_posts(%Scope{} = scope) do Repo.all(from post in Post, where: post.user_id == ^scope.user.id) end ``` The LiveView even subscribes to scoped PubSub messages and automatically updates the rendered list whenever a new post is created or an existing post is updated or deleted, while ensuring that only messages for the current scope are processed. ## Defining scopes The Phoenix generators use your application's config to discover the available scopes. A scope is defined by the following options: ```elixir config :my_app, :scopes, user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users, test_data_fixture: MyApp.AccountsFixtures, test_setup_helper: :register_and_log_in_user ] ``` In this example, the scope is called `user` and it is the `default` scope that is automatically used when running `mix phx.gen.schema`, `mix phx.gen.context`, `mix phx.gen.live`, `mix phx.gen.html` and `mix phx.gen.json`. A scope needs a module that defines a struct, in this case `MyApp.Accounts.Scope`. Those structs are used as first argument to the generated context functions, like `list_posts/1`. * `default` - a boolean that indicates if this scope is the default scope. There can only be one default scope defined. * `module` - the module that defines the struct for this scope. * `assign_key` - the key where the scope struct is assigned to the [socket](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Socket.html#t:t/0) or [conn](https://hexdocs.pm/plug/Plug.Conn.html). * `access_path` - a list of keys that define the path to the identifying field in the scope struct. The generators generate code like `where: schema_key == ^scope.user.id`. * `route_prefix` - (optional) a path template string for how resources should be nested. For example, `/organizations/:org` would generate routes like `/organizations/:org/posts`. The parameter segment (`:org`) will be replaced with the appropriate scope access value in templates and LiveViews. * `route_access_path` - (optional) list of keys that define the path to the field used in route generation (if `route_prefix` is set). This is particularly useful for user-friendly URLs where you might want to use a slug instead of an ID. If not specified, it defaults to `Enum.drop(scope.access_path, -1)` or `access_path` if the former is empty. For example, if the `access_path` is `[:organization, :id]`, it defaults to `[:organization]`, assuming that the value at `scope.organization` implements the `Phoenix.Param` protocol. * `schema_key` - the foreign key that ties the resource to the scope. New scoped schemas are created with a foreign key field named `schema_key` of type `schema_type` to the `schema_table` table. * `schema_type` - the type of the foreign key field in the schema. Typically `:id` or `:binary_id`. * `schema_migration_type` (optional) - the type of the foreign key column in the database. Used for the generated migration. It defaults to the default migration foreign keytype. * `schema_table` - the name of the table where the foreign key points to. * `test_data_fixture` - a module that is automatically imported into the context test file. It must have a `NAME_scope_fixture/0` function that returns a unique scope struct for context tests, in this case `user_scope_fixture/0`. * `test_setup_helper` - the name of a function that is registered as [`setup` callback](https://hexdocs.pm/ex_unit/ExUnit.Callbacks.html#setup/1) in LiveView / Controller tests. The function is expected to be imported in the test file. Usually, this is ensured by putting it into the `MyAppWeb.ConnCase` module. While the `mix phx.gen.auth` automatically generates a scope, scopes can also be defined manually. This can be useful, for example, to retrofit an existing application with scopes or to define scopes that are not tied to a user. For this example, we will implement a custom scope that gives each session its own scope. While this might not be useful in most real-world applications as created resources would be inaccessible as soon as the session ends, it is a good example to understand how scopes work. See the following section for an example on how to augment an existing scope with organizations (teams, companies, or similar). First, let's define our scope module `lib/my_app/scope.ex`: ```elixir defmodule MyApp.Scope do defstruct id: nil def for_id(id) do %MyApp.Scope{id: id} end end ``` Next, we define a plug in our router that assigns a scope to each request: ```diff pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {MyAppWeb.Layouts, :root} plug :protect_from_forgery plug :put_secure_browser_headers + plug :assign_scope end + + defp assign_scope(conn, _opts) do + if id = get_session(conn, :scope_id) do + assign(conn, :current_scope, MyApp.Scope.for_id(id)) + else + id = System.unique_integer() + + conn + |> put_session(:scope_id, id) + |> assign(:current_scope, MyApp.Scope.for_id(id)) + end + end ``` For tests, we'll also define a fixture module `test/support/fixtures/scope_fixtures.ex`: ```elixir defmodule MyApp.ScopeFixtures do alias MyApp.Scope def session_scope_fixture(id \\ System.unique_integer()) do %Scope{id: id} end end ``` And then add a `setup` helper to our `test/support/conn_case.ex`: ```elixir defmodule MyAppWeb.ConnCase do ... def put_scope_in_session(%{conn: conn}) do id = System.unique_integer() scope = MyApp.ScopeFixtures.session_scope_fixture(id) conn = conn |> Phoenix.ConnTest.init_test_session(%{}) |> Plug.Conn.put_session(:scope_id, id) %{conn: conn, scope: scope} end end ``` Finally, we configure the scope in our application's `config/config.exs`: ```elixir config :my_app, :scopes, session: [ default: true, module: MyApp.Scope, assign_key: :current_scope, access_path: [:id], schema_key: :session_id, schema_type: :id, schema_migration_type: :bigint, schema_table: nil, test_data_fixture: MyApp.ScopeFixtures, test_setup_helper: :put_scope_in_session ] ``` Setting `schema_table` to `nil` means that the generated resources don't have a foreign key to the scope, but instead a normal `bigint` column that directly stores the scope's id. We can now generate a new resource, for example with `phx.gen.html`: ```console $ mix phx.gen.html Post posts title:string ``` When you now visit [http://localhost:4000/posts](http://localhost:4000/posts), and create a new post, you will see that it is only visible to the current session. If you open a private browser window and visit the same URL, the previously created post is not visible. Similarly, if you create a new post in the private window, it is not visible in the other window. If you try to copy the URL of a post created in one session and access it in another, you will get an `Ecto.NoResultsError` error, which is automatically converted to 404 when the `debug_errors` setting is disabled. ## Augmenting scopes Let's assume that you used `mix phx.gen.auth` to generate a scope tied to users. But now you also create a new `organization` entity, where users can be members of: ```elixir defmodule MyApp.Accounts.Organization do use Ecto.Schema import Ecto.Changeset @derive {Phoenix.Param, key: :slug} schema "organizations" do field :name, :string field :slug, :string ... many_to_many :users, MyApp.Accounts.User, join_through: "organizations_users" timestamps(type: :utc_datetime) end end ``` First, we'd adjust our scope struct to also include the organization: ```diff defmodule MyApp.Accounts.Scope do alias MyApp.Accounts.User alias MyApp.Accounts.Organization - defstruct user: nil + defstruct user: nil, organization: nil def for_user(%User{} = user) do %__MODULE__{user: user} end def for_user(nil), do: nil + + def put_organization(%__MODULE__{} = scope, %Organization{} = organization) do + %{scope | organization: organization} + end end ``` Let's also assume that the current organization is part of the URL path, like `http://localhost:4000/organizations/foo/posts`. Then, we'd adjust our router to fetch the organization from the path and assign it to the scope: ```diff # router.ex pipeline :browser do ... plug :fetch_current_scope_for_user + plug :assign_org_to_scope end ``` ```elixir # user_auth.ex def assign_org_to_scope(conn, _opts) do current_scope = conn.assigns.current_scope if slug = conn.params["org"] do org = MyApp.Accounts.get_organization_by_slug!(current_scope, slug) assign(conn, :current_scope, MyApp.Accounts.Scope.put_organization(current_scope, org)) else conn end end ``` For LiveViews, we'll also need to add a new `:on_mount` hook and add it to `live_session`'s `on_mount` option in the router: ```diff # router.ex scope "/", MyAppWeb do pipe_through [:browser] live_session :current_user, on_mount: [ {MyAppWeb.UserAuth, :mount_current_scope}, + {MyAppWeb.UserAuth, :assign_org_to_scope} ] do ... end end ``` ```elixir # user_auth.ex def on_mount(:assign_org_to_scope, %{"org" => slug}, _session, socket) do socket = case socket.assigns.current_scope do %{organization: nil} = scope -> org = MyApp.Accounts.get_organization_by_slug!(socket.assigns.current_scope, slug) Phoenix.Component.assign(socket, :current_scope, Scope.put_organization(scope, org)) _ -> socket end {:cont, socket} end def on_mount(:assign_org_to_scope, _params, _session, socket), do: {:cont, socket} ``` This way, if a route is defined like `live /organizations/:org/posts`, the `assign_org_to_scope` plug would fetch the organization from the path and assign it to the scope. This code assumes that `get_organization_by_slug!/2` raises an `Ecto.NoResultsError` which would be automatically converted to `404`, but you could also handle the error explicitly and, for example, set an error flash and redirect to another page, like a dashboard. The `get_organization_by_slug!/2` function should also rely on the current scope to filter the organizations to those the user has access to. Then, we are ready to define a new scope in our application's `config/config.exs` to generate resources scoped to the organization: ```elixir config :my_app, :scopes, user: [ ... ], organization: [ module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:organization, :id], route_prefix: "/organizations/:org", route_access_path: [:organization, :slug], schema_key: :org_id, schema_type: :id, schema_table: :organizations, test_data_fixture: MyApp.AccountsFixtures, test_setup_helper: :register_and_log_in_user_with_org ] ``` For the generated tests, we'll also need to define a fixture in `test/support/fixtures/accounts_fixtures.ex` and extend our `test/support/conn_case.ex`: ```elixir defmodule MyApp.AccountsFixtures do ... def organization_scope_fixture(scope \\ user_scope_fixture()) do org = organization_fixture(scope) Scope.put_organization(scope, org) end end ``` ```elixir defmodule MyAppWeb.ConnCase do ... def register_and_log_in_user_with_org(context) do %{conn: conn, user: _user, scope: scope} = register_and_log_in_user(context) %{conn: conn, scope: MyApp.AccountsFixtures.organization_scope_fixture(scope)} end end ``` Now that our scope configuration includes the `route_prefix`, we can generate resources scoped to the organization, and all paths will be automatically generated with the correct organization slug: ```console $ mix phx.gen.live Blog Post posts title:string body:text --scope organization ``` This shows that scopes are quite flexible, allowing you to keep a well-defined data structure, even when your application grows. Most of the time, your application will have a single scope module, like in this example. But sometimes, you might want to create a new scope module, for example to completely separate a user-facing scope from an admin scope, where also the context functions are supposed to only be called by one of the two. ## Scope helpers When working with more complex scopes, it is often useful to create some helper functions, which can conveniently be added to the scope module: ```elixir defmodule MyApp.Accounts.Scope do alias MyApp.Accounts alias MyApp.Accounts.{User, Organization} defstruct user: nil, organization: nil def for_user(%User{} = user) do %__MODULE__{user: user} end def for_user(nil), do: nil def put_organization(%__MODULE__{} = scope, %Organization{} = organization) do %{scope | organization: organization} end def for(opts) when is_list(opts) do cond do opts[:user] && opts[:org] -> user = user(opts[:user]) org = org(opts[:org]) user |> for_user() |> put_organization(org) opts[:user] -> user = user(opts[:user]) for_user(user) opts[:org] -> %__MODULE__{organization: org(opts[:org])} end end defp user(id) when is_integer(id) do Accounts.get_user!(id) end defp user(email) when is_binary(email) do Accounts.get_user_by_email(email) end defp org(id) when is_integer(id) do Accounts.get_organization!(id) end defp org(slug) when is_binary(slug) do Accounts.get_organization_by_slug!(slug) end end ``` Then, you can alias the Scope module in your project's `.iex.exs`: ```elixir alias MyApp.Accounts.Scope ``` And when working with scoped context functions, you can just do: ```elixir iex> MyApp.Blog.list_posts(Scope.for(user: 1, org: "foo")) ... iex> MyApp.Accounts.list_api_tokens(Scope.for(user: "john@doe.com")) ... ``` ================================================ FILE: guides/cheatsheets/router.cheatmd ================================================ # Routing cheatsheet > Those need to be declared in the correct router module and scope. A quick reference to the common routing features' syntax. For an exhaustive overview, refer to the [routing guides](routing.md). ## Routing declaration {: .col-2} ### Single route ```elixir get "/users", UserController, :index patch "/users/:id", UserController, :update ``` ```elixir # Verified Routes ~p"/users" ~p"/users/#{@user}" ``` Also accepts `put`, `patch`, `options`, `delete` and `head`. ### Resources #### Simple ```elixir resources "/users", UserController ``` Generates `:index`, `:edit`, `:new`, `:show`, `:create`, `:update` and `:delete`. #### Options ```elixir resources "/users", UserController, only: [:show] resources "/users", UserController, except: [:create, :delete] ``` #### Nested ```elixir resources "/users", UserController do resources "/posts", PostController end ``` ```elixir # Verified Routes ~p"/users" ~p"/users/new" ~p"/users/#{@user}" ~p"/users/#{@user}/edit" ~p"/users/#{@user}/posts" ~p"/users/#{@user}/posts/new" ~p"/users/#{@user}/posts/#{@post}" ~p"/users/#{@user}/posts/#{@post}/edit" ``` For more info check the [resources docs.](routing.html#resources) ### Scopes #### Simple ```elixir scope "/admin", HelloWeb.Admin do pipe_through :browser resources "/users", UserController end ``` ```elixir # Verified Routes ~p"/admin/users" ~p"/admin/users/new" ~p"/admin/users/#{@user}" ~p"/admin/users/#{@user}/edit" ``` #### Nested ```elixir scope "/api", HelloWeb.Api do pipe_through :api scope "/v1", V1 do resources "/users", UserController end end ``` ```elixir # Verified Routes ~p"/api/v1/users" ~p"/api/v1/users/new" ~p"/api/v1/users/#{@user}" ~p"/api/v1/users/#{@user}/edit" ``` For more info check the [scoped routes](routing.md#scoped-routes) docs. ================================================ FILE: guides/components.md ================================================ # Components and HEEx > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [request life-cycle guide](request_lifecycle.html). The Phoenix endpoint pipeline takes a request, routes it to a controller, and calls a view module to render a template. The view interface from the controller is simple – the controller calls a view function with the connection's assigns, and the function's job is to return a HEEx template. We call any function that accepts an `assigns` parameter and returns a HEEx template a *function component*. > The Phoenix framework is designed for HTML applications, JSON APIs, GraphQL endpoints, etc. For this reason, all of the functionality related to HTML rendering comes as part of two separate packages: > > * [`phoenix_html`](https://hexdocs.pm/phoenix_html) - defines the building blocks for writing HTML safely. In your project, you'll interact primarily with the `Phoenix.HTML` module, which is imported by default in all templates > > * [`phoenix_live_view`](https://hexdocs.pm/phoenix_live_view) - a library for rich, real-time user experiences with server-rendered HTML. While LiveView provides several abstraction for building collaborative and dynamic applications, it also defines the `HEEx` template language, function components, and JS commands, which brings powerful abstractions for all kinds of server-rendered HTML applications In this chapter, we will recap how components are used and dig deeper to discover new use cases. ## Function components Function components are the essential building block for any kind of markup-based template rendering you'll perform in Phoenix. They serve as a shared abstraction for the standard MVC controller-based applications, LiveView applications, layouts, and smaller UI definitions you'll use throughout other templates. Their documentation is available in [the `Phoenix.Component` module](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html). At the end of the Request life-cycle chapter, we created a template at `lib/hello_web/controllers/hello_html/show.html.heex`, let's open it up: ```heex

Hello World, from {@messenger}!

 ``` `` is a function component defined inside `lib/hello_web/components/layouts.ex`. If you open the file up, you will find: ```elixir def app(assigns) do ~H"""
... ``` So far, all of the function components we have defined also worked as templates. Let's learn more about them by defining our own component with the intent of encapsulating some HTML markup. Imagine we want to refactor our `show.html.heex` to move the rendering of `

Hello World, from {@messenger}!

` to its own function. Remember that `show.html.heex` is embedded within the `HelloHTML` module. Let's open it up: ```elixir defmodule HelloWeb.HelloHTML do use HelloWeb, :html embed_templates "hello_html/*" end ``` That's simple enough. There's only two lines, `use HelloWeb, :html`. This line calls the `html/0` function defined in `HelloWeb` which sets up the basic imports and configuration for our function components and templates. All of the imports and aliases in our module will also be available in our templates. Similarly, if we want to write a function component to be invoked from `show.html.heex`, we can simply add it to `HelloHTML`. Let's do so: ```elixir defmodule HelloWeb.HelloHTML do use HelloWeb, :html embed_templates "hello_html/*" attr :messenger, :string, required: true def greet(assigns) do ~H"""

Hello World, from {@messenger}!

""" end end ``` We declared the attributes we accept via the [`Phoenix.Component.attr/3`](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#attr/3) macro, then we defined our `greet/1` function which returns the HEEx template. Next we need to update `show.html.heex`: ```heex
<.greet messenger={@messenger} />
``` When we reload `http://localhost:4000/hello/Frank`, we should see the same content as before! The `show.html.heex` is now invoking two different function components: * ``. If the component was defined elsewhere, we would need to give its full name, such as: ``. By declaring attributes as required, Phoenix will warn if we call the `<.greet />` component without passing attributes. If an attribute is optional, you can specify the `:default` option with a value: ``` attr :messenger, :string, default: nil ``` Overall, function components are the essential building block of Phoenix rendering stack. Next, let's fully understand the expressive power behind the HEEx template language. ## HEEx Function components and templates files are powered by [the HEEx template language](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#sigil_H/2), which stands for "HTML + Embedded Elixir". We can write Elixir code inside `{...}` for HTML-aware interpolation inside tag attributes and the body, as done above. For example, we use `@name` to access the key `name` defined inside `assigns`. We can also interpolate arbitrary HEEx blocks using `<%= ... %>`. This is often used for block constructs. For example, in order to have conditionals: ```heex <%= if some_condition? do %>

Some condition is true for user: {@messenger}

<% else %>

Some condition is false for user: {@messenger}

<% end %> ``` or even loops: ```heex <%= for number <- 1..10 do %> <% end %>
Number Power
{number} {number * number}
``` HEEx also comes with handy HTML extensions we will learn next. ### HTML extensions Besides allowing interpolation of Elixir expressions, `.heex` templates come with HTML-aware extensions. For example, let's see what happens if you try to interpolate a value with "<" or ">" in it, which would lead to HTML injection: ```heex {"Bold?"} ``` Once you render the template, you will see the literal `` on the page. This means users cannot inject HTML content on the page. If you want to allow them to do so, you can call `raw`, but do so with extreme care: ```heex {raw("Bold?")} ``` Another super power of HEEx templates is validation of HTML and interpolation syntax of attributes. You can write: ```heex

Hello {@username}

``` Notice how you could simply use `key={value}`. HEEx will automatically handle special values such as `false` to remove the attribute or a list of classes. To interpolate a dynamic number of attributes in a keyword list or map, do: ```heex

Hello {@username}

``` Also, try removing the closing `` or renaming it to ``. HEEx templates will let you know about your error. HEEx also supports shorthand syntax for `if` and `for` expressions via the special `:if` and `:for` attributes. For example, rather than this: ```heex <%= if @some_condition do %>
...
<% end %> ``` You can write: ```heex
...
``` Likewise, for comprehensions may be written as: ```heex
  • {item.name}
``` ## CoreComponents In a new Phoenix application, you will also find a `core_components.ex` module inside the `components` folder. This module is a great example of defining function components to be reused throughout our application. This guarantees that, as our application evolves, our components will look consistent. If you look inside `def html` in `HelloWeb` placed at `lib/hello_web.ex`, you will see that `CoreComponents` are automatically imported into all HTML views via `use HelloWeb, :html`. This is also the reason why `CoreComponents` itself performs `use Phoenix.Component` instead of `use HelloWeb, :html` at the top: doing the latter would cause a deadlock as we would try to import `CoreComponents` into itself. CoreComponents also play an important role in Phoenix code generators, as the code generators assume those components are available in order to quickly scaffold your application. In case you want to learn more about all of these pieces, you may: * Explore the generated `CoreComponents` module to learn more from practical examples * Read the official documentation for [`Phoenix.Component`](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html) * Read the official documentation for [HEEx and the ~H sigils](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#sigil_H/2) * If you are looking for higher level components beyond the minimal ones included by Phoenix, [the LiveView project keeps a list of component systems](https://github.com/phoenixframework/phoenix_live_view#component-systems) ## Layouts When talking about components and rendering in Phoenix, it is important to understand the concept of layouts. All Phoenix applications have one component called the "root layout". This page is where you will find the `` and `` tags of your HTML page. The root layout is configured in your `lib/hello_web/router.ex` file: ```elixir plug :put_root_layout, html: {HelloWeb.Layouts, :root} ``` In a newly generated app, the template itself can be found at `lib/hello_web/components/layouts/root.html.heex`. Open it up and, just about at the end of the ``, you will see this: ```heex {@inner_content} ``` That's where our templates are injected once they are rendered. The root layout is reused by controllers and live views alike. Any dynamic functionality of your application is then implemented as function components. For example, your application menu and sidebar is typically part of the `app` component in `lib/hello_web/components/layouts.ex`, which is invoked in every template: ```heex ... ``` This mechanism is also very flexible. For example, if you want to create an admin layout, you can simply add a new function in the `Layouts` module, and then invoke `Layouts.admin` instead of `Layouts.app`: ```heex ... ``` > Previous Phoenix versions used a nested layout mechanism, by passing the `:layouts` to `Phoenix.Controller` and `:layout` to `Phoenix.LiveView`, but this mechanism is discouraged in new Phoenix applications. ================================================ FILE: guides/controllers.md ================================================ # Controllers > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [request life-cycle guide](request_lifecycle.html). Phoenix controllers act as intermediary modules. Their functions — called actions — are invoked from the router in response to HTTP requests. The actions, in turn, gather all the necessary data and perform all the necessary steps before invoking the view layer to render a template or returning a JSON response. Phoenix controllers also build on the Plug package, and are themselves plugs. Controllers provide the functions to do almost anything we need to in an action. If we do find ourselves looking for something that Phoenix controllers don't provide, we might find what we're looking for in Plug itself. Please see the [Plug guide](plug.html) or the [Plug documentation](`Plug`) for more information. A newly generated Phoenix app will have a single controller named `PageController`, which can be found at `lib/hello_web/controllers/page_controller.ex` which looks like this: ```elixir defmodule HelloWeb.PageController do use HelloWeb, :controller def home(conn, _params) do render(conn, :home) end end ``` The first line below the module definition invokes the `__using__/1` macro of the `HelloWeb` module, which imports some useful modules. `PageController` gives us the `home` action to display the Phoenix [welcome page] associated with the default route Phoenix defines in the router. ## Actions Controller actions are just functions. We can name them anything we like as long as they follow Elixir's naming rules. The only requirement we must fulfill is that the action name matches a route defined in the router. For example, in `lib/hello_web/router.ex` we could change the action name in the default route that Phoenix gives us in a new app from `home`: ```elixir get "/", PageController, :home ``` to `index`: ```elixir get "/", PageController, :index ``` as long as we change the action name in `PageController` to `index` as well, the [welcome page] will load as before. ```elixir defmodule HelloWeb.PageController do ... def index(conn, _params) do render(conn, :home) end end ``` While we can name our actions whatever we like, there are conventions for action names which we should follow whenever possible. We went over these in the [routing guide](routing.html), but we'll take another quick look here. - index - renders a list of all items of the given resource type - show - renders an individual item by ID - new - renders a form for creating a new item - create - receives parameters for one new item and saves it in a data store - edit - retrieves an individual item by ID and displays it in a form for editing - update - receives parameters for one edited item and saves the item to a data store - delete - receives an ID for an item to be deleted and deletes it from a data store Each of these actions takes two parameters, which will be provided by Phoenix behind the scenes. The first parameter is always `conn`, a struct which holds information about the request such as the host, path elements, port, query string, and much more. `conn` comes to Phoenix via Elixir's Plug middleware framework. More detailed information about `conn` can be found in the [Plug.Conn documentation](`Plug.Conn`). The second parameter is `params`. Not surprisingly, this is a map which holds any parameters passed along in the HTTP request. It is a good practice to pattern match against parameters in the function signature to provide data in a simple package we can pass on to rendering. We saw this in the [request life-cycle guide](request_lifecycle.html) when we added a messenger parameter to our `show` route in `lib/hello_web/controllers/hello_controller.ex`. ```elixir defmodule HelloWeb.HelloController do ... def show(conn, %{"messenger" => messenger}) do render(conn, :show, messenger: messenger) end end ``` In some cases — often in `index` actions, for instance — we don't care about parameters because our behavior doesn't depend on them. In those cases, we don't use the incoming parameters, and simply prefix the variable name with an underscore, calling it `_params`. This will keep the compiler from complaining about the unused variable while still keeping the correct arity. ## Rendering Controllers can render content in several ways. The simplest is to render some plain text using the [`text/2`] function which Phoenix provides. For example, let's rewrite the `show` action from `HelloController` to return text instead. For that, we could do the following. ```elixir def show(conn, %{"messenger" => messenger}) do text(conn, "From messenger #{messenger}") end ``` Now [`/hello/Frank`] in your browser should display `From messenger Frank` as plain text without any HTML. A step beyond this is rendering pure JSON with the [`json/2`] function. We need to pass it something that the [Jason library](`Jason`) can decode into JSON, such as a map. (Jason is one of Phoenix's dependencies.) ```elixir def show(conn, %{"messenger" => messenger}) do json(conn, %{id: messenger}) end ``` If we again visit [`/hello/Frank`] in the browser, we should see a block of JSON with the key `id` mapped to the string `"Frank"`. ```json {"id": "Frank"} ``` The [`json/2`] function is useful for writing APIs and there is also the [`html/2`] function for rendering HTML, but most of the times we use Phoenix views to build our responses. For this, Phoenix includes the [`render/3`] function. It is specially important for HTML responses, as Phoenix Views provide performance and security benefits. Let's rollback our `show` action to what we originally wrote in the [request life-cycle guide](request_lifecycle.html): ```elixir defmodule HelloWeb.HelloController do use HelloWeb, :controller def show(conn, %{"messenger" => messenger}) do render(conn, :show, messenger: messenger) end end ``` In order for the [`render/3`] function to work correctly, the controller and view must share the same root name (in this case `Hello`), and the `HelloHTML` module must include an `embed_templates` definition specifying where its templates live. By default the controller, view module, and templates are collocated together in the same controller directory. In other words, `HelloController` requires `HelloHTML`, and `HelloHTML` requires the existence of the `lib/hello_web/controllers/hello_html/` directory, which must contain the `show.html.heex` template. [`render/3`] will also pass the value which the `show` action received for `messenger` from the parameters as an assign. If we need to pass values into the template when using `render`, that's easy. We can pass a keyword like we've seen with `messenger: messenger`, or we can use `Plug.Conn.assign/3`, which conveniently returns `conn`. ```elixir def show(conn, %{"messenger" => messenger}) do conn |> Plug.Conn.assign(:messenger, messenger) |> render(:show) end ``` Note: Using `Phoenix.Controller` imports `Plug.Conn`, so shortening the call to [`assign/3`] works just fine. Passing more than one value to our template is as simple as connecting [`assign/3`] functions together: ```elixir def show(conn, %{"messenger" => messenger}) do conn |> assign(:messenger, messenger) |> assign(:receiver, "Dweezil") |> render(:show) end ``` Or you can pass the assigns directly to `render` instead: ```elixir def show(conn, %{"messenger" => messenger}) do render(conn, :show, messenger: messenger, receiver: "Dweezil") end ``` Generally speaking, once all assigns are configured, we invoke the view layer. The view layer (`HelloWeb.HelloHTML`) then renders `show.html` alongside the layout and a response is sent back to the browser. ## New rendering formats Rendering HTML through a template is fine, but what if we need to change the rendering format on the fly? Let's say that sometimes we need HTML, sometimes we need plain text, and sometimes we need JSON. Then what? The view's job is not only to render HTML templates. Views are about data presentation. Given a bag of data, the view's purpose is to present that in a meaningful way given some format, be it HTML, JSON, CSV, or others. Many web apps today return JSON to remote clients, and Phoenix views are *great* for JSON rendering. As an example, let's take `PageController`'s `home` action from a newly generated app. Out of the box, this has the right view `PageHTML`, the embedded templates from (`lib/hello_web/controllers/page_html`), and the right template for rendering HTML (`home.html.heex`.) ```elixir def home(conn, _params) do render(conn, :home) end ``` What it doesn't have is a view for rendering JSON. Phoenix Controller hands off to a view module to render templates, and it does so per format. We already have a view for the HTML format, but we need to instruct Phoenix how to render the JSON format as well. By default, you can see which formats your controllers support in `lib/hello_web.ex`: ```elixir def controller do quote do use Phoenix.Controller, formats: [:html, :json] ... end end ``` So out of the box Phoenix will look for a `HTML` and `JSON` view modules based on the request format and the controller name. We can also explicitly tell Phoenix in our controller which view(s) to use for each format. For example, what Phoenix does by default can be explicitly set with the following in your controller: ```elixir plug :put_view, html: HelloWeb.PageHTML, json: HelloWeb.PageJSON ``` Let's add a `PageJSON` view module at `lib/hello_web/controllers/page_json.ex`: ```elixir defmodule HelloWeb.PageJSON do def home(_assigns) do %{message: "this is some JSON"} end end ``` Since the Phoenix View layer is simply a function that the controller renders, passing connection assigns, we can define a regular `home/1` function and return a map to be serialized as JSON. There are just a few more things we need to do to make this work. Because we want to render both HTML and JSON from the same controller, we need to tell our router that it should accept the `json` format. We do that by adding `json` to the list of accepted formats in the `:browser` pipeline. Let's open up `lib/hello_web/router.ex` and change `plug :accepts` to include `json` as well as `html` like this. ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :browser do plug :accepts, ["html", "json"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.LayoutView, :root} plug :protect_from_forgery plug :put_secure_browser_headers end ... ``` Phoenix allows us to change formats on the fly with the `_format` query string parameter. If we go to [`http://localhost:4000/?_format=json`](http://localhost:4000/?_format=json), we will see `%{"message": "this is some JSON"}`. In practice, however, applications that need to render both formats typically use two distinct pipelines for each, such as the `pipeline :api` already defined in your router file. To learn more, see [our JSON and APIs guide](json_and_apis.md). ### Sending responses directly If none of the rendering options above quite fits our needs, we can compose our own using some of the functions that `Plug` gives us. Let's say we want to send a response with a status of "201" and no body whatsoever. We can do that with the `Plug.Conn.send_resp/3` function. Edit the `home` action of `PageController` in `lib/hello_web/controllers/page_controller.ex` to look like this: ```elixir def home(conn, _params) do send_resp(conn, 201, "") end ``` Reloading [http://localhost:4000](http://localhost:4000) should show us a completely blank page. The network tab of our browser's developer tools should show a response status of "201" (Created). Some browsers (Safari) will download the response, as the content type is not set. To be specific about the content type, we can use [`put_resp_content_type/2`] in conjunction with [`send_resp/3`]. ```elixir def home(conn, _params) do conn |> put_resp_content_type("text/plain") |> send_resp(201, "") end ``` Using `Plug` functions in this way, we can craft just the response we need. ### Setting the content type Analogous to the `_format` query string param, we can render any sort of format we want by modifying the HTTP Content-Type Header and providing the appropriate template. If we wanted to render an XML version of our `home` action, we might implement the action like this in `lib/hello_web/controllers/page_controller.ex`. ```elixir def home(conn, _params) do conn |> put_resp_content_type("text/xml") |> put_format(:xml) |> render(:home, content: some_xml_content) end ``` Then we would need to provide a `home.xml.eex` template that creates XML and a `PageXML` view that embeds the template, and that would be it. Note: The `home.xml.eex` template uses the `.eex` extension. `.eex` templates are rendered by [`EEx`](https://hexdocs.pm/eex/main/EEx.html). For a list of valid content mime-types, please see the `MIME` library. ### Setting the HTTP Status We can also set the HTTP status code of a response similarly to the way we set the content type. The `Plug.Conn` module, imported into all controllers, has a `put_status/2` function to do this. `Plug.Conn.put_status/2` takes `conn` as the first parameter and as the second parameter either an integer or a "friendly name" used as an atom for the status code we want to set. The list of status code atom representations can be found in `Plug.Conn.Status.code/1` documentation. Let's change the status in our `PageController` `home` action. ```elixir def home(conn, _params) do conn |> put_status(202) |> render(:home) end ``` The status code we provide must be a valid number. ## Redirection Often, we need to redirect to a new URL in the middle of a request. A successful `create` action, for instance, will usually redirect to the `show` action for the resource we just created. Alternately, it could redirect to the `index` action to show all the things of that same type. There are plenty of other cases where redirection is useful as well. Whatever the circumstance, Phoenix controllers provide the handy [`redirect/2`] function to make redirection easy. Phoenix differentiates between redirecting to a path within the application and redirecting to a URL — either within our application or external to it. In order to try out [`redirect/2`], let's create a new route in `lib/hello_web/router.ex`. ```elixir defmodule HelloWeb.Router do ... scope "/", HelloWeb do ... get "/", PageController, :home get "/redirect_test", PageController, :redirect_test ... end end ``` Then we'll change `PageController`'s `home` action of our controller to do nothing but to redirect to our new route. ```elixir defmodule HelloWeb.PageController do use HelloWeb, :controller def home(conn, _params) do redirect(conn, to: ~p"/redirect_test") end end ``` We made use of `Phoenix.VerifiedRoutes.sigil_p/2` to build our redirect path, which is the preferred approach to reference any path within our application. We learned about verified routes in the [routing guide](routing.html). Finally, let's define in the same file the action we redirect to, which simply renders the home, but now under a new address: ```elixir def redirect_test(conn, _params) do render(conn, :home) end ``` When we reload our [welcome page], we see that we've been redirected to `/redirect_test` which shows the original welcome page. It works! If we care to, we can open up our developer tools, click on the network tab, and visit our root route again. We see two main requests for this page - a get to `/` with a status of `302`, and a get to `/redirect_test` with a status of `200`. Notice that the redirect function takes `conn` as well as a string representing a relative path within our application. For security reasons, the `:to` option can only redirect to paths within your application. If you want to redirect to a fully-qualified path or an external URL, you should use `:external` instead: ```elixir def home(conn, _params) do redirect(conn, external: "https://elixir-lang.org/") end ``` ## Flash messages Sometimes we need to communicate with users during the course of an action. Maybe there was an error updating a schema, or maybe we just want to welcome them back to the application. For this, we have flash messages. The `Phoenix.Controller` module provides the [`put_flash/3`] to set flash messages as a key-value pair and placing them into a `@flash` assign in the connection. Let's set two flash messages in our `HelloWeb.PageController` to try this out. To do this we modify the `home` action as follows: ```elixir defmodule HelloWeb.PageController do ... def home(conn, _params) do conn |> put_flash(:error, "Let's pretend we have an error.") |> render(:home) end end ``` In order to see our flash messages, we need to be able to retrieve them and display them in a template layout. We can do that using [`Phoenix.Flash.get/2`] which takes the flash data and the key we care about. It then returns the value for that key. For our convenience, a `flash_group` component is already available and added to the beginning of our [welcome page] ```heex <.flash_group flash={@flash} /> ``` When we reload the [welcome page], our message should appear in the top right corner of the page. The flash functionality is handy when mixed with redirects. Perhaps you want to redirect to a page with some extra information. If we reuse the redirect action from the previous section, we can do: ```elixir def home(conn, _params) do conn |> put_flash(:error, "Let's pretend we have an error.") |> redirect(to: ~p"/redirect_test") end ``` Now if you reload the [welcome page], you will be redirected and the flash message will be shown once more. Besides [`put_flash/3`], the `Phoenix.Controller` module has another useful function worth knowing about. [`clear_flash/1`] takes only `conn` and removes any flash messages which might be stored in the session. Phoenix does not enforce which keys are stored in the flash. As long as we are internally consistent, all will be well. `:info` and `:error`, however, are common and are handled by default in our templates. ## Error pages Phoenix has two views called `ErrorHTML` and `ErrorJSON` which live in `lib/hello_web/controllers/`. The purpose of these views is to handle errors in a general way for incoming HTML or JSON requests. Similar to the views we built in this guide, error views can return both HTML and JSON responses. See the [Custom Error Pages How-To](custom_error_pages.html) for more information. [`render/4`]: `Phoenix.Template.render/4` [`/hello/Frank`]: http://localhost:4000/hello/Frank [`assign/3`]: `Plug.Conn.assign/3` [`clear_flash/1`]: `Phoenix.Controller.clear_flash/1` [`Phoenix.Flash.get/2`]: `Phoenix.Flash.get/2` [`html/2`]: `Phoenix.Controller.html/2` [`json/2`]: `Phoenix.Controller.json/2` [`put_flash/3`]: `Phoenix.Controller.put_flash/3` [`put_resp_content_type/2`]: `Plug.Conn.put_resp_content_type/2` [`put_root_layout/2`]: `Phoenix.Controller.put_root_layout/2` [`redirect/2`]: `Phoenix.Controller.redirect/2` [`render/3`]: `Phoenix.Controller.render/3` [`send_resp/3`]: `Plug.Conn.send_resp/3` [`text/2`]: `Phoenix.Controller.text/2` [welcome page]: http://localhost:4000/ ================================================ FILE: guides/data_modelling/contexts.md ================================================ # 1. Intro to Contexts Phoenix guides are broken into several major sections. The main building blocks are outlined under the "Core Concepts" section, where we explored [the request life-cycle](request_lifecycle.html), wired up controller actions through our routers, and learned how Ecto allows data to be validated and persisted. Now it's time to tie it all together by writing web-facing features that interact with our greater Elixir application. When building a Phoenix project, we are first and foremost building an Elixir application. Phoenix's job is to provide a web interface into our Elixir application. Naturally, we compose our applications with modules and functions, but we often assign specific responsibilities to certain modules and give them names: such as controllers, routers, and live views. However, the most important part of your web application is often where we encapsulate data access and data validation. We call these modules **contexts**. They often talk to a database, using `Ecto`, or APIs, using an HTTP client such as `Req`. By giving these modules a name, we help developers identify these patterns and talk about them. At the end of the day, contexts are just modules, as are your controllers, views, etc. If you have used `mix phx.gen.html`, `mix phx.gen.json`, or `mix phx.gen.live`, you have already used contexts. For example, run the following generator in a Phoenix application: ```console $ mix phx.gen.live Post posts title body:text ``` The command above will output a few files, among them, a `MyApp.Posts.Post` schema in `lib/my_app/posts/post.ex`, which outlines how the resource is represented in the database, and a **context** module named `MyApp.Posts` that encapsulates all the database access to said schema. The `MyApp.Posts` module centralizes all functionality related to posts, instead of scattering logic around controllers, LiveViews, etc. Contexts are also useful to nest resources. For example, if you are adding comments to your posts, you can colocate their schemas, since comments belong to posts, like this: ```console $ mix phx.gen.live Posts Comment comments post_id:references:posts body:text ``` The first argument to the generator above is the context module, instructing Phoenix to colocate the comments functionality with posts. There is also a `post_id` attribute which specifies a foreign key reference to the posts table. As your application grows, contexts help you group related schemas, instead of having several dozens of schemas with no insights on how they relate to each other. Developers may also use contexts to intentionally name parts of their application. For example, `mix phx.gen.auth` requires a context name to be explicitly given. It is often invoked as: ```console $ mix phx.gen.auth Accounts User users ``` or, using whatever name you prefer, such as: ```console $ mix phx.gen.auth Identity Client clients ``` The generated `Accounts` (or `Identity`) context will encapsulate all functionality for managing users (or clients) and their tokens. You could, if you wanted, name the context `Users` too, but given account/identity management has well defined name and boundary in most applications, giving it an explicit name makes its purposes clear. And, at the end of the day, they are just plain modules. In this guide, we will use these ideas to build out our web application. Our goal is to build an ecommerce system where we can showcase products, allow users to add products to their cart, and complete their orders. We will do so by intentionally designing and naming our contexts. Opposite to other Phoenix guides, **these guides are meant to be read in order**. ## Our ecommerce application Let's start an application from scratch to build our ecommerce, using Phoenix Express. We will call the application `hello`. For macOS/Ubuntu: ```bash $ curl https://new.phoenixframework.org/hello | sh ``` For Windows PowerShell: ```bash curl.exe -fsSO https://new.phoenixframework.org/hello.bat; .\hello.bat ``` If those commands do not work, see the [Installation Guide](installation.html) and then run `mix phx.new`: ```console $ mix phx.new hello ``` Follow any of the steps printed on the screen and open up the generated `hello` project in your editor. We are ready to move to the next chapter. ================================================ FILE: guides/data_modelling/cross_context_boundaries.md ================================================ # 4. Cross-context Boundaries Now that we have the beginnings of our product catalog features, let's begin to work on the other main features of our application – carting products from the catalog. In order to properly track products that have been added to a user's cart, we'll need a new place to persist this information, along with point-in-time product information like the price at time of carting. This is necessary so we can detect product price changes in the future. We know what we need to build, but now we need to decide where the cart functionality lives in our application. If we take a step back and think about the isolation of our application, the exhibition of products in our catalog distinctly differs from the responsibilities of managing a user's cart. A product catalog shouldn't care about the rules of our shopping cart system, and vice-versa. There's a clear need here for a separate context to handle the new cart responsibilities. Let's call it `ShoppingCart`. Let's create a `ShoppingCart` context to handle basic cart duties. Before we write code, let's imagine we have the following feature requirements: 1. Add products to a user's cart from the product show page 2. Store point-in-time product price information at time of carting 3. Store and update quantities in cart 4. Calculate and display sum of cart prices From the description, it's clear we need a `Cart` resource for storing the user's cart, along with a `CartItem` to track products in the cart. With our plan set, let's get to work. ## Adding authentication Most of the cart functionality is tied to a specific user. Therefore, in order to allow each user to manage their own cart (and only their own carts), we must be able to authenticate users. To do so, we will use Phoenix's built-in `mix phx.gen.auth` generator to scaffold a solution for us: ```console mix phx.gen.auth Accounts User users ``` You will see output similar to the following: ```console An authentication system can be created in two different ways: - Using Phoenix.LiveView (default) - Using Phoenix.Controller only Do you want to create a LiveView based authentication system? [Yn] ``` Type `n` followed by `Return` key, you will see output similar to: ```console ... * creating lib/hello/accounts/scope.ex ... * injecting config/config.exs ... Please re-fetch your dependencies with the following command: $ mix deps.get Remember to update your repository by running migrations: $ mix ecto.migrate Once you are ready, visit "/users/register" to create your account and then access "/dev/mailbox" to see the account confirmation email. ``` After following the instructions to re-fetch dependencies and migrating the database, we can start the server with `mix phx.server` and re-visit the home page [`http://localhost:4000/`](http://localhost:4000/). There, we should see new registration and login links at the top of the page. On the registration page, create a new user. In development, a confirmation email is sent to the dev mailbox, which is accessible at [`http://localhost:4000/dev/mailbox`](http://localhost:4000/dev/mailbox). After clicking the confirmation link, you should be successfully logged in. One of the benefits of `mix phx.gen.auth` is that it also generates a scope file at `lib/hello/accounts/scope.ex`. In a nutshell, authentication tells us who a user is based on their email address, but it doesn't tell us the resources the user owns or has access to. In order to do so, we need authorization. Scopes help us tie generated resources, such as the Cart we will create, to users. Let's open up the file: ```elixir defmodule Hello.Accounts.Scope do ... alias Hello.Accounts.User defstruct user: nil @doc """ Creates a scope for the given user. Returns nil if no user is given. """ def for_user(%User{} = user) do %__MODULE__{user: user} end def for_user(nil), do: nil end ``` We can see that it is simply a struct with a `user` field. The authentication system ensures that the `current_scope` assign is accordingly set with the current user. Let's see it in practice. ## Generating scoped resources Let's generate our new context: ```console $ mix phx.gen.context ShoppingCart Cart carts * creating lib/hello/shopping_cart/cart.ex * creating priv/repo/migrations/20250205203128_create_carts.exs * creating lib/hello/shopping_cart.ex * injecting lib/hello/shopping_cart.ex * creating test/hello/shopping_cart_test.exs * injecting test/hello/shopping_cart_test.exs * creating test/support/fixtures/shopping_cart_fixtures.ex * injecting test/support/fixtures/shopping_cart_fixtures.ex Remember to update your repository by running migrations: $ mix ecto.migrate ``` We generated our new context `ShoppingCart`, with a new `ShoppingCart.Cart` schema. Open up the generated schema and migration files and you will see it has automatically included a `user_id` field, thanks to the scope. Furthermore, when we explore the code later on, we will learn all queries to the carts table have been properly scoped. With our cart in place, let's generate our cart items. This time we will pass the `--no-scope` flag, because we will associate `cart_items` to `carts` and the `carts` are already scoped to the user: ```console $ mix phx.gen.context ShoppingCart CartItem cart_items \ cart_id:references:carts product_id:references:products \ price_when_carted:decimal quantity:integer --no-scope You are generating into an existing context. ... Would you like to proceed? [Yn] y * creating lib/hello/shopping_cart/cart_item.ex * creating priv/repo/migrations/20250205213410_create_cart_items.exs * injecting lib/hello/shopping_cart.ex * injecting test/hello/shopping_cart_test.exs * injecting test/support/fixtures/shopping_cart_fixtures.ex Remember to update your repository by running migrations: $ mix ecto.migrate ``` We generated a new resource inside our `ShoppingCart` named `CartItem`. This schema and table will hold references to a cart and product, along with the price at the time we added the item to our cart, and the quantity the user wishes to purchase. Let's touch up the generated migration file in `priv/repo/migrations/*_create_cart_items.ex`: ```diff create table(:cart_items) do - add :price_when_carted, :decimal + add :price_when_carted, :decimal, precision: 15, scale: 6, null: false add :quantity, :integer - add :cart_id, references(:carts, on_delete: :nothing) + add :cart_id, references(:carts, on_delete: :delete_all) - add :product_id, references(:products, on_delete: :nothing) + add :product_id, references(:products, on_delete: :delete_all) timestamps(type: :utc_datetime) end - create index(:cart_items, [:cart_id]) create index(:cart_items, [:product_id]) + create unique_index(:cart_items, [:cart_id, :product_id]) ``` We used the `:delete_all` strategy again to enforce data integrity. This way, when a cart or product is deleted from the application, we don't have to rely on application code in our `ShoppingCart` or `Catalog` contexts to worry about cleaning up the records. This keeps our application code decoupled and the data integrity enforcement where it belongs – in the database. We also added a unique constraint to ensure a duplicate product is not allowed to be added to a cart. As with the `product_categories` table, using a multi-column index lets us remove the separate index for the leftmost field (`cart_id`). With our database tables in place, we can now migrate up: ```console $ mix ecto.migrate 16:59:51.941 [info] == Running 20250205203342 Hello.Repo.Migrations.CreateCarts.change/0 forward 16:59:51.945 [info] create table carts 16:59:51.952 [info] == Migrated 20250205203342 in 0.0s 16:59:51.988 [info] == Running 20250205213410 Hello.Repo.Migrations.CreateCartItems.change/0 forward 16:59:51.988 [info] create table cart_items 16:59:52.000 [info] create index cart_items_product_id_index 16:59:52.001 [info] create index cart_items_cart_id_product_id_index 16:59:52.002 [info] == Migrated 20250205213410 in 0.0s ``` Our database is ready to go with new `carts` and `cart_items` tables, but now we need to map that back into application code. You may be wondering how we can mix database foreign keys across different tables and how that relates to the context pattern of isolated, grouped functionality. Let's jump in and discuss the approaches and their tradeoffs. ## Cross-context data So far, we've done a great job isolating the two main contexts of our application from each other, but now we have a necessary dependency to handle. Our `Catalog.Product` resource serves to keep the responsibilities of representing a product inside the catalog, but ultimately for an item to exist in the cart, a product from the catalog must be present. Given this, our `ShoppingCart` context will have a data dependency on the `Catalog` context. With that in mind, we have two options. One is to expose APIs on the `Catalog` context that allows us to efficiently fetch product data for use in the `ShoppingCart` system, which we would manually stitch together. Or we can use database joins to fetch the dependent data. Both are valid options given your tradeoffs and application size, but joining data from the database when you have a hard data dependency is just fine for a large class of applications and is the approach we will take here. Now that we know where our data dependencies exist, let's add our schema associations so we can tie shopping cart items to products. First, let's make a quick change to our cart schema in `lib/hello/shopping_cart/cart.ex` to associate a cart to its items: ```diff schema "carts" do - field :user_id, :id + belongs_to :user, Hello.Accounts.User + has_many :items, Hello.ShoppingCart.CartItem timestamps(type: :utc_datetime) end ``` Now that our cart is associated to the items we place in it, let's set up the cart item associations inside `lib/hello/shopping_cart/cart_item.ex`: ```diff schema "cart_items" do field :price_when_carted, :decimal field :quantity, :integer - field :cart_id, :id - field :product_id, :id + belongs_to :cart, Hello.ShoppingCart.Cart + belongs_to :product, Hello.Catalog.Product timestamps(type: :utc_datetime) end @doc false def changeset(cart_item, attrs) do cart_item - |> cast(attrs, [:price_when_carted, :quantity]) + |> cast(attrs, [:quantity]) - |> validate_required([:price_when_carted, :quantity]) + |> validate_required([:quantity]) + |> validate_number(:quantity, greater_than_or_equal_to: 0, less_than: 100) end ``` First, we replaced the `cart_id` field with a standard `belongs_to` pointing at our `ShoppingCart.Cart` schema. Next, we replaced our `product_id` field by adding our first cross-context data dependency with a `belongs_to` for the `Catalog.Product` schema. Here, we intentionally coupled the data boundaries because it provides exactly what we need: an isolated context API with the bare minimum knowledge necessary to reference a product in our system. Second, we remove `price_when_carted` from the list of permitted attributes to ensure any price provided by user input is discarded. Finally, we added a new validation to our changeset. With `validate_number/3`, we ensure any quantity provided by user input is between 0 and 100. With our schemas in place, we can start integrating the new data structures and `ShoppingCart` context APIs into our web-facing features. ## Adding Cart functions As we mentioned before, the context generators are only a starting point for our application. We can and should write well-named, purpose built functions to accomplish the goals of our context. We have a few new features to implement. First, we need to ensure every user of our application is granted a cart if one does not yet exist. From there, we can then allow users to add items to their cart, update item quantities, and calculate cart totals. Let's get started! Because we used `mix phx.gen.auth`, we already have a real authentication system in place. We can use the `current_scope` assign to access the currently authenticated user. Let's add a new plug that assigns a cart if there is an authenticated user: ```diff pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.LayoutView, :root} plug :protect_from_forgery plug :put_secure_browser_headers plug :fetch_current_scope_for_user + plug :fetch_current_cart end + alias Hello.ShoppingCart + + defp fetch_current_cart(%{assigns: %{current_scope: scope}} = conn, _opts) when not is_nil(scope) do + if cart = ShoppingCart.get_cart(scope) do + assign(conn, :cart, cart) + else + {:ok, new_cart} = ShoppingCart.create_cart(scope, %{}) + assign(conn, :cart, new_cart) + end + end + + defp fetch_current_cart(conn, _opts), do: conn ``` We added a new `:fetch_current_cart` plug which either finds a cart for the user UUID or creates a cart for the current user and assigns the result in the connection assigns. We'll need to implement our `ShoppingCart.get_cart/1`, but let's add our routes first. We'll need to implement a cart controller for handling cart operations like viewing a cart, updating quantities, and initiating the checkout process, as well as a cart items controller for adding and removing individual items to and from the cart. The authentication system already generated different router scopes that have different authentication requirements: ```elixir ... ## Authentication routes scope "/", HelloWeb do pipe_through [:browser, :redirect_if_user_is_authenticated] get "/user/register", UserRegistrationController, :new post "/user/register", UserRegistrationController, :create end scope "/", HelloWeb do pipe_through [:browser, :require_authenticated_user] get "/user/settings", UserSettingsController, :edit put "/user/settings", UserSettingsController, :update get "/user/settings/confirm-email/:token", UserSettingsController, :confirm_email end ... ``` As you can see, the registration route has a `:redirect_if_user_is_authenticated` plug, which means it will redirect to the home page if the user is already authenticated. The user settings routes use a `:require_authenticated_user` plug, which means they will redirect to the log in page if the user is not authenticated. These plugs are defined in the `lib/hello_web/user_auth.ex` module. For our cart routes, we want to only allow access to authenticated users. Add the following routes to your router in `lib/hello_web/router.ex`: ```diff scope "/", HelloWeb do pipe_through :browser get "/", PageController, :index resources "/products", ProductController end + scope "/", HelloWeb do + pipe_through [:browser, :require_authenticated_user] + + resources "/cart_items", CartItemController, only: [:create, :delete] + + get "/cart", CartController, :show + put "/cart", CartController, :update + end ``` We added a `resources` declaration for a `CartItemController`, which will wire up the routes for a create and delete action for adding and removing individual cart items. Next, we added two new routes pointing at a `CartController`. The first route, a GET request, will map to our show action, to show the cart contents. The second route, a PUT request, will handle the submission of a form for updating our cart quantities. With our routes in place, let's add the ability to add an item to our cart from the product show page. Create a new file at `lib/hello_web/controllers/cart_item_controller.ex` and key this in: ```elixir defmodule HelloWeb.CartItemController do use HelloWeb, :controller alias Hello.ShoppingCart def create(conn, %{"product_id" => product_id}) do case ShoppingCart.add_item_to_cart(conn.assigns.current_scope, conn.assigns.cart, product_id) do {:ok, _item} -> conn |> put_flash(:info, "Item added to your cart") |> redirect(to: ~p"/cart") {:error, _changeset} -> conn |> put_flash(:error, "There was an error adding the item to your cart") |> redirect(to: ~p"/cart") end end def delete(conn, %{"id" => product_id}) do {:ok, _cart} = ShoppingCart.remove_item_from_cart(conn.assigns.current_scope, conn.assigns.cart, product_id) redirect(conn, to: ~p"/cart") end end ``` We defined a new `CartItemController` with the create and delete actions that we declared in our router. For `create`, we call a `ShoppingCart.add_item_to_cart/3` function which we'll implement in a moment. If successful, we show a flash successful message and redirect to the cart show page; else, we show a flash error message and redirect to the cart show page. For `delete`, we'll call a `remove_item_from_cart` function which we'll implement on our `ShoppingCart` context and then redirect back to the cart show page. We haven't implemented these two shopping cart functions yet, but notice how their names scream their intent: `add_item_to_cart` and `remove_item_from_cart` make it obvious what we are accomplishing here. It also allows us to spec out our web layer and context APIs without thinking about all the implementation details at once. Let's implement the new interface for the `ShoppingCart` context API in `lib/hello/shopping_cart.ex`: ```diff + alias Hello.Catalog - alias Hello.ShoppingCart.Cart + alias Hello.ShoppingCart.{Cart, CartItem} alias Hello.Accounts.Scope + def get_cart(%Scope{} = scope) do + Repo.one( + from(c in Cart, + where: c.user_id == ^scope.user.id, + left_join: i in assoc(c, :items), + left_join: p in assoc(i, :product), + order_by: [asc: i.inserted_at], + preload: [items: {i, product: p}] + ) + ) + end def create_cart(%Scope{} = scope, attrs) do with {:ok, cart = %Cart{}} <- %Cart{} |> Cart.changeset(attrs, scope) |> Repo.insert() do broadcast(scope, {:created, cart}) - {:ok, cart} + {:ok, get_cart(scope)} end end + + def add_item_to_cart(%Scope{} = scope, %Cart{} = cart, product_id) do + true = cart.user_id == scope.user.id + product = Catalog.get_product!(product_id) + + %CartItem{quantity: 1, price_when_carted: product.price} + |> CartItem.changeset(%{}) + |> Ecto.Changeset.put_assoc(:cart, cart) + |> Ecto.Changeset.put_assoc(:product, product) + |> Repo.insert( + on_conflict: [inc: [quantity: 1]], + conflict_target: [:cart_id, :product_id] + ) + end + + def remove_item_from_cart(%Scope{} = scope, %Cart{} = cart, product_id) do + true = cart.user_id == scope.user.id + + {1, _} = + Repo.delete_all( + from(i in CartItem, + where: i.cart_id == ^cart.id, + where: i.product_id == ^product_id + ) + ) + + {:ok, get_cart(scope)} + end ``` We started by implementing `get_cart/1` which fetches our cart and joins the cart items, and their products so that we have the full cart populated with all preloaded data. Next, we modified our `create_cart` function to use `get_cart` to reload the cart contents. Next, we wrote our new `add_item_to_cart/3` function which accepts a scope, a cart struct and a product id. We proceed to fetch the product with `Catalog.get_product!/1`, showing how contexts can naturally invoke other contexts if required. You could also have chosen to receive the product as argument and you would achieve similar results. Then we used an upsert operation against our repo to either insert a new cart item into the database, or increase the quantity by one if it already exists in the cart. This is accomplished via the `on_conflict` and `conflict_target` options, which tells our repo how to handle an insert conflict. Finally, we implemented `remove_item_from_cart/3` where we simply issue a `Repo.delete_all` call with a query to delete the cart item in our cart that matches the product ID. Finally, we reload the cart contents by calling `get_cart/1`. With our new cart functions in place, we can now expose the "Add to cart" button on the product catalog show page. Open up your template in `lib/hello_web/controllers/product_html/show.html.heex` and make the following changes: ```diff ... <.button variant="primary" navigate={~p"/products/#{@product}/edit?return_to=show"}> <.icon name="hero-pencil-square" /> Edit product + <.button href={~p"/cart_items?product_id=#{@product.id}"} method="post"> + Add to cart + ... ``` The `link` function component from `Phoenix.Component` accepts a `:method` attribute to issue an HTTP verb when clicked, instead of the default GET request. With this link in place, the "Add to cart" link will issue a POST request, which will be matched by the route we defined in router which dispatches to the `CartItemController.create/2` function. Let's try it out. Start your server with `mix phx.server` and visit a product page. If we try clicking the add to cart link, we'll be greeted by an error page. If you are authenticated the following logs should be visible in the console: ```text [info] POST /cart_items [debug] Processing with HelloWeb.CartItemController.create/2 Parameters: %{"_method" => "post", "product_id" => "1", ...} Pipelines: [:browser, :require_authenticated_user] [debug] QUERY OK source="user_tokens" db=2.4ms idle=1340.8ms ... [debug] QUERY OK source="cart_items" db=2.5ms INSERT INTO "cart_items" ... [info] Sent 302 in 24ms [info] GET /cart [debug] Processing with HelloWeb.CartController.show/2 Parameters: %{} Pipelines: [:browser, :require_authenticated_user] [debug] QUERY OK source="user_tokens" db=1.6ms idle=430.2ms ... [debug] QUERY OK source="carts" db=1.9ms idle=1798.5ms ... [info] Sent 500 in 18ms [error] ** (UndefinedFunctionError) function HelloWeb.CartController.init/1 is undefined (module HelloWeb.CartController is not available) ... ``` It's working! Kind of. If we follow the logs, we see our POST to the `/cart_items` path. Next, we can see our `ShoppingCart.add_item_to_cart` function successfully inserted a row into the `cart_items` table, and then we issued a redirect to `/cart`. Before our error, we also see a query to the `carts` table, which means we're fetching the current user's cart. So far so good. We know our `CartItem` controller and new `ShoppingCart` context functions are doing their jobs, but we've hit our next unimplemented feature when the router attempts to dispatch to a nonexistent cart controller. Let's create the cart controller, view, and template to display and manage user carts. Create a new file at `lib/hello_web/controllers/cart_controller.ex` and key this in: ```elixir defmodule HelloWeb.CartController do use HelloWeb, :controller alias Hello.ShoppingCart def show(conn, _params) do render(conn, :show, changeset: ShoppingCart.change_cart(conn.assigns.current_scope, conn.assigns.cart)) end end ``` We defined a new cart controller to handle the `get "/cart"` route. For showing a cart, we render a `"show.html"` template which we'll create in a moment. We know we need to allow the cart items to be changed by quantity updates, so right away we know we'll need a cart changeset. Fortunately, the context generator included a `ShoppingCart.change_cart/1` function, which we'll use. We pass it our cart struct which is already in the connection assigns thanks to the `fetch_current_cart` plug we defined in the router. Next, we can implement the view and template. Create a new view file at `lib/hello_web/controllers/cart_html.ex` with the following content: ```elixir defmodule HelloWeb.CartHTML do use HelloWeb, :html alias Hello.ShoppingCart embed_templates "cart_html/*" def currency_to_str(%Decimal{} = val), do: "$#{Decimal.round(val, 2)}" end ``` We created a view to render our `show.html` template and aliased our `ShoppingCart` context so it will be in scope for our template. We'll need to display the cart prices like product item price, cart total, etc, so we defined a `currency_to_str/1` which takes our decimal struct, rounds it properly for display, and prepends a USD dollar sign. Next we can create the template at `lib/hello_web/controllers/cart_html/show.html.heex`: ```heex <.header> My Cart <:subtitle :if={@cart.items == []}>Your cart is empty
<.form :let={f} for={@changeset} action={~p"/cart"}> <.inputs_for :let={%{data: item} = item_form} field={f[:items]}> <.input field={item_form[:quantity]} type="number" label={item.product.title} /> {currency_to_str(ShoppingCart.total_item_price(item))} <.button>Update cart Total: {currency_to_str(ShoppingCart.total_cart_price(@cart))}
<.button navigate={~p"/products"}>Back to products ``` We started by showing the empty cart message if our preloaded `cart.items` is empty. If we have items, we use the `form` component provided by our `HelloWeb.CoreComponents` to take our cart changeset that we assigned in the `CartController.show/2` action and create a form which maps to our cart controller `update/2` action. Within the form, we use the [`inputs_for`](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#inputs_for/1) component to render inputs for the nested cart items. This will allow us to map item inputs back together when the form is submitted. Next, we display a number input for the item quantity and label it with the product title. We finish the item form by converting the item price to string. We haven't written the `ShoppingCart.total_item_price/1` function yet, but again we employed the idea of clear, descriptive public interfaces for our contexts. After rendering inputs for all the cart items, we show an "update cart" submit button, along with the total price of the entire cart. This is accomplished with another new `ShoppingCart.total_cart_price/1` function which we'll implement in a moment. Finally, we added a `back` component to go back to our products page. We're almost ready to try out our cart page, but first we need to implement our new currency calculation functions. Open up your shopping cart context at `lib/hello/shopping_cart.ex` and add these new functions: ```elixir def total_item_price(%CartItem{} = item) do Decimal.mult(item.product.price, item.quantity) end def total_cart_price(%Cart{} = cart) do Enum.reduce(cart.items, 0, fn item, acc -> item |> total_item_price() |> Decimal.add(acc) end) end ``` We implemented `total_item_price/1` which accepts a `%CartItem{}` struct. To calculate the total price, we simply take the preloaded product's price and multiply it by the item's quantity. We used `Decimal.mult/2` to take our decimal currency struct and multiply it with proper precision. Similarly for calculating the total cart price, we implemented a `total_cart_price/1` function which accepts the cart and sums the preloaded product prices for items in the cart. We again make use of the `Decimal` functions to add our decimal structs together. Now that we can calculate price totals, let's try it out! Visit [`http://localhost:4000/cart`](http://localhost:4000/cart) and you should already see your first item in the cart. Going back to the same product and clicking "add to cart" will show our upsert in action. Your quantity should now be two. Nice work! Our cart page is almost complete, but submitting the form will yield yet another error. ```text [info] POST /cart ... [error] ** (UndefinedFunctionError) function HelloWeb.CartController.update/2 is undefined or private ``` Let's head back to our `CartController` at `lib/hello_web/controllers/cart_controller.ex` and implement the update action: ```elixir def update(conn, %{"cart" => cart_params}) do case ShoppingCart.update_cart(conn.assigns.current_scope, conn.assigns.cart, cart_params) do {:ok, _cart} -> redirect(conn, to: ~p"/cart") {:error, _changeset} -> conn |> put_flash(:error, "There was an error updating your cart") |> redirect(to: ~p"/cart") end end ``` We started by plucking out the cart params from the form submit. Next, we call our existing `ShoppingCart.update_cart/2` function which was added by the context generator. We'll need to make some changes to this function, but the interface is good as is. If the update is successful, we redirect back to the cart page, otherwise we show a flash error message and send the user back to the cart page to fix any mistakes. Out-of-the-box, our `ShoppingCart.update_cart/2` function only concerned itself with casting the cart params into a changeset and updates it against our repo. For our purposes, we now need it to handle nested cart item associations, and most importantly, business logic for how to handle quantity updates like zero-quantity items being removed from the cart. Head back over to your shopping cart context in `lib/hello/shopping_cart.ex` and replace your `update_cart/2` function with the following implementation: ```elixir def update_cart(%Scope{} = scope, %Cart{} = cart, attrs) do true = cart.user_id == scope.user.id changeset = cart |> Cart.changeset(attrs, scope) |> Ecto.Changeset.cast_assoc(:items, with: &CartItem.changeset/2) Repo.transact(fn -> with {:ok, cart} <- Repo.update(changeset), {_count, _cart_items} = Repo.delete_all(from(i in CartItem, where: i.cart_id == ^cart.id and i.quantity == 0)) do {:ok, cart} end end) |> case do {:ok, cart} -> broadcast_cart(scope, {:updated, cart}) {:ok, cart} {:error, reason} -> {:error, reason} end end ``` We started much like how our out-of-the-box code started – we take the cart struct and cast the user input to a cart changeset, except this time we use `Ecto.Changeset.cast_assoc/3` to cast the nested item data into `CartItem` changesets. Remember the [`<.inputs_for />`](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#inputs_for/1) call in our cart form template? That hidden ID data is what allows Ecto's `cast_assoc` to map item data back to existing item associations in the cart. Once the `changeset` is ready, we wrap everything in `Repo.transact/2` so the operations run safely as one. Inside the transaction, we update the cart using `Repo.update/1`. If the update succeeds, we follow up with a cleanup step using `Repo.delete_all/2` to remove any cart items with zero quantity. Running both steps in the same transaction prevents partial updates and keeps the cart data accurate. Finally, we broadcast the updated cart so that any connected LiveViews can instantly show the changes. Let's head back to the browser and try it out. Add a few products to your cart, update the quantities, and watch the values changes along with the price calculations. Setting any quantity to 0 will also remove the item. You can also try logging out and registering a new user to see how the carts are scoped to the current user. Pretty neat! ================================================ FILE: guides/data_modelling/faq.md ================================================ # 6. FAQ Here we list frequently asked questions about contexts. ## When to use code generators? In this guide, we have used code generators for schemas, contexts, controllers, and more. If you are happy to move forward with Phoenix defaults, feel free to rely on generators to scaffold large parts of your application. When using Phoenix generators, the main question you need to answer is: does this new functionality (with its schema, table, and fields) belong to one of the existing contexts or a new one? This way, Phoenix generators guide you to use contexts to group related functionality, instead of having several dozens of schemas laying around without any structure. And remember: if you're stuck when trying to come up with a context name, you can simply use the plural form of the resource you're creating. ## How do I structure code inside contexts? You may wonder how to organize the code inside contexts. For example, should you define a module for changesets (such as ProductChangesets) and another module for queries (such as ProductQueries)? One important benefit of contexts is that this decision does not matter much. The context is your public API, the other modules are private. Contexts isolate these modules into small groups so the surface area of your application is the context and not _all of your code_. So while you and your team could establish patterns for organizing these private modules, it is also our opinion that it is completely fine for them to be different. The major focus should be on how the contexts are defined and how they interact with each other (and with your web application). Think about it as a well-kept neighbourhood. Your contexts are houses, you want to keep them well-preserved, well-connected, etc. Inside the houses, they may all be a little bit different, and that's fine. ## Returning Ecto structures from context APIs As we explored the context API, you might have wondered: > If one of the goals of our context is to encapsulate Ecto Repo access, why does `create_user/1` return an `Ecto.Changeset` struct when we fail to create a user? Although Changesets are part of Ecto, they are not tied to the database, and they can be used to map data from and to any source, which makes it a general and useful data structure for tracking field changes, perform validations, and generate error messages. For those reasons, `%Ecto.Changeset{}` is a good choice to model the data changes between your contexts and your web layer - regardless if you are talking to an API or the database. Finally, note that your controllers and views are not hardcoded to work exclusively with Ecto either. Instead, Phoenix defines protocols such as `Phoenix.Param` and `Phoenix.HTML.FormData`, which allow any library to extend how Phoenix generates URL parameters or renders forms. Conveniently for us, the `phoenix_ecto` project implements those protocols, but you could as well bring your own data structures and implement them yourself. ================================================ FILE: guides/data_modelling/in_context_relationships.md ================================================ # 3. In-context Relationships Our basic catalog features are nice, but let's take it up a notch by categorizing products. Many ecommerce solutions allow products to be categorized in different ways, such as a product being marked for fashion, power tools, and so on. Starting with a one-to-one relationship between product and categories will cause major code changes later if we need to start supporting multiple categories. Let's set up a category association that will allow us to start off tracking a single category per product, but easily support more later as we grow our features. For now, categories will contain only textual information. Our first order of business is to decide where categories live in the application. We have our `Catalog` context, which manages the exhibition of our products. Product categorization is a natural fit here. Phoenix is also smart enough to generate code inside an existing context, which makes adding new resources to a context a breeze. Run the following command at your project root: > Sometimes it may be tricky to determine if two resources belong to the same context or not. In those cases, prefer distinct contexts per resource and refactor later if necessary. Otherwise you can easily end up with large contexts of loosely related entities. Also keep in mind that the fact two resources are related does not necessarily mean they belong to the same context, otherwise you would quickly end up with one large context, as the majority of resources in an application are connected to each other. To sum it up: if you are unsure, you should prefer separate modules (contexts). ```console mix phx.gen.context Catalog Category categories \ title:string:unique --no-scope ``` You will see the following output in your terminal: ```console You are generating into an existing context. The Hello.Catalog context currently has 7 functions and 1 file in its directory. * It's OK to have multiple resources in the same context as long as they are closely related. ... Would you like to proceed? [Yn] ``` Type `y` followed by the `Return` key. You should see output similar to: ```console * creating lib/hello/catalog/category.ex * creating priv/repo/migrations/20250203192325_create_categories.exs * injecting lib/hello/catalog.ex * injecting test/hello/catalog_test.exs * injecting test/support/fixtures/catalog_fixtures.ex Remember to update your repository by running migrations: $ mix ecto.migrate ``` This time around, we used `mix phx.gen.context`, which is just like `mix phx.gen.html`, except it doesn't generate the web files for us. Since we already have controllers and templates for managing products, we can integrate the new category features into our existing web form and product show page. We can see we now have a new `Category` schema alongside our product schema at `lib/hello/catalog/category.ex`, and Phoenix told us it was *injecting* new functions in our existing Catalog context for the category functionality. The injected functions will look very familiar to our product functions, with new functions like `create_category`, `list_categories`, and so on. Before we migrate up, we need to do a second bit of code generation. Our category schema is great for representing an individual category in the system, but we need to support a many-to-many relationship between products and categories. Fortunately, ecto allows us to do this simply with a join table, so let's generate that now with the `ecto.gen.migration` command: ```console mix ecto.gen.migration create_product_categories ``` You will see output confirming the migration file was created: ```console * creating priv/repo/migrations/20250203192958_create_product_categories.exs ``` Next, let's open up the new migration file and add the following code to the `change` function: ```elixir defmodule Hello.Repo.Migrations.CreateProductCategories do use Ecto.Migration def change do create table(:product_categories, primary_key: false) do add :product_id, references(:products, on_delete: :delete_all) add :category_id, references(:categories, on_delete: :delete_all) end create index(:product_categories, [:product_id]) create unique_index(:product_categories, [:category_id, :product_id]) end end ``` We created a `product_categories` table and used the `primary_key: false` option since our join table does not need a primary key. Next we defined our `:product_id` and `:category_id` foreign key fields, and passed `on_delete: :delete_all` to ensure the database prunes our join table records if a linked product or category is deleted. By using a database constraint, we enforce data integrity at the database level, rather than relying on ad-hoc and error-prone application logic. Next, we created indexes for our foreign keys, one of which is a unique index to ensure a product cannot have duplicate categories. Note that we do not necessarily need single-column index for `category_id` because it is in the leftmost prefix of multicolumn index, which is enough for the database optimizer. Adding a redundant index, on the other hand, only adds overhead on write. With our migrations in place, we can migrate up. ```console mix ecto.migrate ``` You will see the following output confirming migration success: ``` 18:20:36.489 [info] == Running 20250222231834 Hello.Repo.Migrations.CreateCategories.change/0 forward 18:20:36.493 [info] create table categories 18:20:36.508 [info] create index categories_title_index 18:20:36.512 [info] == Migrated 20250222231834 in 0.0s 18:20:36.547 [info] == Running 20250222231930 Hello.Repo.Migrations.CreateProductCategories.change/0 forward 18:20:36.547 [info] create table product_categories 18:20:36.557 [info] create index product_categories_product_id_index 18:20:36.560 [info] create index product_categories_category_id_product_id_index 18:20:36.562 [info] == Migrated 20250222231930 in 0.0s ``` Now that we have a `Catalog.Product` schema and a join table to associate products and categories, we're nearly ready to start wiring up our new features. Before we dive in, we first need real categories to select in our web UI. Let's quickly seed some new categories in the application. Add the following code to your seeds file in `priv/repo/seeds.exs`: ```elixir for title <- ["Home Improvement", "Power Tools", "Gardening", "Books", "Education"] do {:ok, _} = Hello.Catalog.create_category(%{title: title}) end ``` We simply enumerate over a list of category titles and use the generated `create_category/1` function of our catalog context to persist the new records. We can run the seeds with `mix run`: ```console mix run priv/repo/seeds.exs ``` The output in the terminal confirms the `seeds.exs` executed successfully: ```console [debug] QUERY OK db=3.1ms decode=1.1ms queue=0.7ms idle=2.2ms INSERT INTO "categories" ("title","inserted_at","updated_at") VALUES ($1,$2,$3) RETURNING "id" ["Home Improvement", ~N[2025-02-03 19:39:53], ~N[2025-02-03 19:39:53]] [debug] QUERY OK db=1.2ms queue=1.3ms idle=12.3ms INSERT INTO "categories" ("title","inserted_at","updated_at") VALUES ($1,$2,$3) RETURNING "id" ["Power Tools", ~N[2025-02-03 19:39:53], ~N[2025-02-03 19:39:53]] [debug] QUERY OK db=1.1ms queue=1.1ms idle=15.1ms INSERT INTO "categories" ("title","inserted_at","updated_at") VALUES ($1,$2,$3) RETURNING "id" ["Gardening", ~N[2025-02-03 19:39:53], ~N[2025-02-03 19:39:53]] [debug] QUERY OK db=2.4ms queue=1.0ms idle=17.6ms INSERT INTO "categories" ("title","inserted_at","updated_at") VALUES ($1,$2,$3) RETURNING "id" ["Books", ~N[2025-02-03 19:39:53], ~N[2025-02-03 19:39:53]] ``` Perfect. Before we integrate categories in the web layer, we need to let our context know how to associate products and categories. First, open up `lib/hello/catalog/product.ex` and add the following association: ```diff + alias Hello.Catalog.Category schema "products" do field :description, :string field :price, :decimal field :title, :string field :views, :integer + many_to_many :categories, Category, join_through: "product_categories", on_replace: :delete timestamps(type: :utc_datetime) end ``` We used `Ecto.Schema`'s `many_to_many` macro to let Ecto know how to associate our product to multiple categories through the `"product_categories"` join table. We also used the `on_replace: :delete` option to declare that any existing join records should be deleted when we are changing our categories. With our schema associations set up, we can implement the selection of categories in our product form. To do so, we need to translate the user input of catalog IDs from the front-end to our many-to-many association. Fortunately Ecto makes this a breeze now that our schema is set up. Open up your catalog context and make the following changes: ```diff + alias Hello.Catalog.Category - def get_product!(id), do: Repo.get!(Product, id) + def get_product!(id) do + Product + |> Repo.get!(id) + |> Repo.preload(:categories) + end def create_product(attrs) do %Product{} - |> Product.changeset(attrs) + |> change_product(attrs) |> Repo.insert() end def update_product(%Product{} = product, attrs) do product - |> Product.changeset(attrs) + |> change_product(attrs) |> Repo.update() end def change_product(%Product{} = product, attrs \\ %{}) do - Product.changeset(product, attrs) + categories = list_categories_by_id(attrs["category_ids"]) + product + |> Repo.preload(:categories) + |> Product.changeset(attrs) + |> Ecto.Changeset.put_assoc(:categories, categories) end + def list_categories_by_id(nil), do: [] + def list_categories_by_id(category_ids) do + Repo.all(from c in Category, where: c.id in ^category_ids) + end ``` First, we added `Repo.preload` to preload our categories when we fetch a product. This will allow us to reference `product.categories` in our controllers, templates, and anywhere else we want to make use of category information. Next, we modified our `create_product` and `update_product` functions to call into our existing `change_product` function to produce a changeset. Within `change_product` we added a lookup to find all categories if the `"category_ids"` attribute is present. Then we preloaded categories and called `Ecto.Changeset.put_assoc` to place the fetched categories into the changeset. Finally, we implemented the `list_categories_by_id/1` function to query the categories matching the category IDs, or return an empty list if no `"category_ids"` attribute is present. Now our `create_product` and `update_product` functions receive a changeset with the category associations all ready to go once we attempt an insert or update against our repo. Next, let's expose our new feature to the web by adding the category input to our product form. To keep our form template tidy, let's write a new function to wrap up the details of rendering a category select input for our product. Open up your `ProductHTML` view in `lib/hello_web/controllers/product_html.ex` and key this in: ```elixir def category_opts(changeset) do existing_ids = changeset |> Ecto.Changeset.get_change(:categories, []) |> Enum.map(& &1.data.id) for cat <- Hello.Catalog.list_categories() do [key: cat.title, value: cat.id, selected: cat.id in existing_ids] end end ``` We added a new `category_opts/1` function which generates the select options for a multiple select tag we will add soon. We calculated the existing category IDs from our changeset, then used those values when we generate the select options for the input tag. We did this by enumerating over all of our categories and returning the appropriate `key`, `value`, and `selected` values. We marked an option as selected if the category ID was found in those category IDs in our changeset. With our `category_opts` function in place, we can open up `lib/hello_web/controllers/product_html/product_form.html.heex` and add: ```diff ... <.input field={f[:views]} type="number" label="Views" /> + <.input field={f[:category_ids]} type="select" multiple options={category_opts(@changeset)} /> <.button>Save Product ``` We added a `category_select` above our save button. Now let's try it out. Next, let's show the product's categories in the product show template. Add the following code to the list in `lib/hello_web/controllers/product_html/show.html.heex`: ```diff <.list> ... + <:item title="Categories"> +
    +
  • {cat.title}
    • +
+ ``` Now if we start the server with `mix phx.server` and visit [http://localhost:4000/products/new](http://localhost:4000/products/new), we'll see the new category multiple select input. Enter some valid product details, select a category or two, and click save. ```text Title: Elixir Flashcards Description: Flash card set for the Elixir programming language Price: 5.000000 Views: 0 Categories: Education Books ``` It's not much to look at yet, but it works! We added relationships within our context complete with data integrity enforced by the database. Not bad. Let's keep building! ================================================ FILE: guides/data_modelling/more_examples.md ================================================ # 5. Bringing It Home With our `Catalog` and `ShoppingCart` contexts, we're seeing first-hand how our well-considered modules and function names are yielding clear and maintainable code. Our last order of business is to allow the user to initiate the checkout process. We won't go as far as integrating payment processing or order fulfillment, but we'll get you started in that direction. This will be a great opportunity to put what we have learned so far in practice. Like before, we need to decide where code for completing an order should live. Is it part of the catalog? Clearly not, but what about the shopping cart? Shopping carts are related to orders – after all, the user has to add items in order to purchase any products – but should the order checkout process be grouped here? If we stop and consider the order process, we'll see that orders involve related, but distinctly different data from the cart contents. Also, business rules around the checkout process are much different than carting. For example, we may allow a user to add a back-ordered item to their cart, but we could not allow an order with no inventory to be completed. Additionally, we need to capture point-in-time product information when an order is completed, such as the price of the items *at payment transaction time*. This is essential because a product price may change in the future, but the line items in our order must always record and display what we charged at time of purchase. For these reasons, we can start to see that ordering can stand on its own with its own data concerns and business rules. Naming wise, `Orders` clearly defines our context, so let's get started by again taking advantage of the context generators. Note that the `user` scope generated by `mix phx.gen.auth` is marked as default scope (in your `config/config.exs`), therefore we don't need to specify it in our command. There can be different scopes in an application, in which case the `--scope` option can be used when running the generators. Run the following command in your console: ```console $ mix phx.gen.context Orders Order orders total_price:decimal * creating lib/hello/orders/order.ex * creating priv/repo/migrations/20250209214612_create_orders.exs * creating lib/hello/orders.ex * injecting lib/hello/orders.ex * creating test/hello/orders_test.exs * injecting test/hello/orders_test.exs * creating test/support/fixtures/orders_fixtures.ex * injecting test/support/fixtures/orders_fixtures.ex Remember to update your repository by running migrations: $ mix ecto.migrate ``` We generated an `Orders` context. The order is automatically scoped to the current user and added a `total_price` column. With our starting point in place, let's open up the newly created migration in `priv/repo/migrations/*_create_orders.exs` and make the following changes: ```diff def change do create table(:orders) do - add :total_price, :decimal + add :total_price, :decimal, precision: 15, scale: 6, null: false add :user_id, references(:users, type: :id, on_delete: :delete_all) timestamps(type: :utc_datetime) end end ``` Like we did previously, we gave appropriate precision and scale options for our decimal column which will allow us to store currency without precision loss. We also added a not-null constraint to enforce all orders to have a price. The orders table alone doesn't hold much information, but we know we'll need to store point-in-time product price information of all the items in the order. For that, we'll add an additional struct for this context named `LineItem`. Line items will capture the price of the product *at payment transaction time*. Please run the following command: ```console $ mix phx.gen.context Orders LineItem order_line_items \ price:decimal quantity:integer \ order_id:references:orders product_id:references:products --no-scope You are generating into an existing context. ... Would you like to proceed? [Yn] y * creating lib/hello/orders/line_item.ex * creating priv/repo/migrations/20250209215050_create_order_line_items.exs * injecting lib/hello/orders.ex * injecting test/hello/orders_test.exs * injecting test/support/fixtures/orders_fixtures.ex Remember to update your repository by running migrations: $ mix ecto.migrate ``` We used the `phx.gen.context` command to generate the `LineItem` Ecto schema and inject supporting functions into our orders context. Like before, let's modify the migration in `priv/repo/migrations/*_create_order_line_items.exs` and make the following decimal field changes: ```diff def change do create table(:order_line_items) do - add :price, :decimal + add :price, :decimal, precision: 15, scale: 6, null: false add :quantity, :integer add :order_id, references(:orders, on_delete: :nothing) add :product_id, references(:products, on_delete: :nothing) timestamps(type: :utc_datetime) end create index(:order_line_items, [:order_id]) create index(:order_line_items, [:product_id]) end ``` With our migration in place, let's wire up our orders and line items associations in `lib/hello/orders/order.ex`: ```diff schema "orders" do field :total_price, :decimal - field :user_id, :id + belongs_to :user, Hello.Accounts.User + has_many :line_items, Hello.Orders.LineItem + has_many :products, through: [:line_items, :product] timestamps(type: :utc_datetime) end ``` We used `has_many :line_items` to associate orders and line items, just like we've seen before. Next, we used the `:through` feature of `has_many`, which allows us to instruct ecto how to associate resources across another relationship. In this case, we can associate products of an order by finding all products through associated line items. Next, let's wire up the association in the other direction in `lib/hello/orders/line_item.ex`: ```diff schema "order_line_items" do field :price, :decimal field :quantity, :integer - field :order_id, :id - field :product_id, :id + belongs_to :order, Hello.Orders.Order + belongs_to :product, Hello.Catalog.Product timestamps(type: :utc_datetime) end ``` We used `belongs_to` to associate line items to orders and products. With our associations in place, we can start integrating the web interface into our order process. Open up your router `lib/hello_web/router.ex` and add the following line: ```diff scope "/", HelloWeb do pipe_through [:browser, :require_authenticated_user] resources "/cart_items", CartItemController, only: [:create, :delete] get "/cart", CartController, :show put "/cart", CartController, :update + resources "/orders", OrderController, only: [:create, :show] end ``` We wired up `create` and `show` routes for our generated `OrderController`, since these are the only actions we need at the moment. With our routes in place, we can now migrate up: ```console $ mix ecto.migrate 17:14:37.715 [info] == Running 20250209214612 Hello.Repo.Migrations.CreateOrders.change/0 forward 17:14:37.720 [info] create table orders 17:14:37.755 [info] == Migrated 20250209214612 in 0.0s 17:14:37.784 [info] == Running 20250209215050 Hello.Repo.Migrations.CreateOrderLineItems.change/0 forward 17:14:37.785 [info] create table order_line_items 17:14:37.795 [info] create index order_line_items_order_id_index 17:14:37.796 [info] create index order_line_items_product_id_index 17:14:37.798 [info] == Migrated 20250209215050 in 0.0s ``` Before we render information about our orders, we need to ensure our order data is fully populated and can be looked up by a current user. Open up your orders context in `lib/hello/orders.ex` and adjust your `get_order!/2` to include a preload: ```diff def get_order!(%Scope{} = scope, id) do - Repo.get_by!(Order, id: id, user_id: scope.user.id) + Order + |> Repo.get_by!(id: id, user_id: scope.user.id) + |> Repo.preload([line_items: [:product]]) end ``` To complete an order, our cart page can issue a POST to the `OrderController.create` action, but we need to implement the operations and logic to actually complete an order. Like before, we'll start at the web interface. Create a new file at `lib/hello_web/controllers/order_controller.ex` and key this in: ```elixir defmodule HelloWeb.OrderController do use HelloWeb, :controller alias Hello.Orders def create(conn, _) do case Orders.complete_order(conn.assigns.current_scope, conn.assigns.cart) do {:ok, order} -> conn |> put_flash(:info, "Order created successfully.") |> redirect(to: ~p"/orders/#{order}") {:error, _reason} -> conn |> put_flash(:error, "There was an error processing your order") |> redirect(to: ~p"/cart") end end end ``` We wrote the `create` action to call an as-yet-implemented `Orders.complete_order/2` function. Our code is technically "creating" an order, but it's important to step back and consider the naming of your interfaces. The act of *completing* an order is extremely important in our system. Money changes hands in a transaction, physical goods could be automatically shipped, etc. Such an operation deserves a better, more obvious function name, such as `complete_order`. If the order is completed successfully we redirect to the show page, otherwise a flash error is shown as we redirect back to the cart page. Here is also a good opportunity to highlight that contexts can naturally work with data defined by other contexts too. This will be especially common with data that is used throughout the application, such as the cart here (but it can also be the current user or the current project, and so forth, depending on your project). Now we can implement our `Orders.complete_order/2` function. To complete an order, our job will require a few operations: 1. A new order record must be persisted with the total price of the order 2. All items in the cart must be transformed into new order line items records with quantity and point-in-time product price information 3. After successful order insert (and eventual payment), items must be pruned from the cart From our requirements alone, we can start to see why a generic `create_order` function doesn't cut it. Let's implement this new function in `lib/hello/orders.ex`: ```elixir alias Hello.Orders.LineItem alias Hello.ShoppingCart def complete_order(%Scope{} = scope, %ShoppingCart.Cart{} = cart) do true = cart.user_id == scope.user.id line_items = Enum.map(cart.items, fn item -> %{ product_id: item.product_id, price: item.product.price, quantity: item.quantity } end) order_changeset = Ecto.Changeset.change(%Order{}, %{ user_id: scope.user.id, total_price: ShoppingCart.total_cart_price(cart), line_items: line_items }) Repo.transact(fn -> with {:ok, order} <- Repo.insert(order_changeset), {:ok, _cart} <- ShoppingCart.prune_cart_items(scope, cart) do {:ok, order} end end) |> case do {:ok, order} -> broadcast_order(scope, {:created, order}) {:ok, order} {:error, reason} -> {:error, reason} end end ``` We started by mapping the `%ShoppingCart.CartItem{}`'s in our shopping cart into a map of order line items structs. The job of the order line item record is to capture the price of the product *at payment transaction time*, so we reference the product's price here. Next, we create a bare order changeset with `Ecto.Changeset.change/2` and associate our user UUID, set our total price calculation, and place our order line items in the changeset. With a fresh order changeset ready to be inserted, we now make use of `Repo.transact/2` to execute our operations in a database transaction. We start by inserting the order, followed by a step that prunes all items from the user’s cart. The function wrapped inside `Repo.transact/2` must either return `{:ok, result}` or error, which halts and rolls back the transaction. Running the transaction will execute these operations in sequence, and we return the result to the caller once completed. To close out our order completion, we need to implement the `ShoppingCart.prune_cart_items/1` function in `lib/hello/shopping_cart.ex`: ```elixir def prune_cart_items(%Scope{} = scope, %Cart{} = cart) do {_, _} = Repo.delete_all(from(i in CartItem, where: i.cart_id == ^cart.id)) {:ok, get_cart(scope)} end ``` Our new function accepts the cart struct and issues a `Repo.delete_all` which accepts a query of all items for the provided cart. We return a success result by simply reloading the pruned cart to the caller. With our context complete, we now need to show the user their completed order. Head back to your order controller and add the `show/2` action: ```elixir def show(conn, %{"id" => id}) do order = Orders.get_order!(conn.assigns.current_scope, id) render(conn, :show, order: order) end ``` We added the show action to pass our `conn.assigns.current_scope` to `get_order!` which authorizes orders to be viewable only by the owner of the order. Next, we can implement the view and template. Create a new view file at `lib/hello_web/controllers/order_html.ex` with the following content: ```elixir defmodule HelloWeb.OrderHTML do use HelloWeb, :html embed_templates "order_html/*" end ``` Next we can create the template at `lib/hello_web/controllers/order_html/show.html.heex`: ```heex <.header> Thank you for your order! <:subtitle> Email: {@current_scope.user.email} <.table id="items" rows={@order.line_items}> <:col :let={item} label="Title">{item.product.title} <:col :let={item} label="Quantity">{item.quantity} <:col :let={item} label="Price"> {HelloWeb.CartHTML.currency_to_str(item.price)} Total price: {HelloWeb.CartHTML.currency_to_str(@order.total_price)} <.button navigate={~p"/products"}>Back to products ``` To show our completed order, we displayed the order's user, followed by the line item listing with product title, quantity, and the price we "transacted" when completing the order, along with the total price. Our last addition will be to add the "complete order" button to our cart page to allow completing an order. Add the following button to the <.header> of the cart show template in `lib/hello_web/controllers/cart_html/show.html.heex`: ```diff <.header> My Cart + <:actions> + <.button href={~p"/orders"} method="post"> + Complete order + + ``` We added a link with `method="post"` to send a POST request to our `OrderController.create` action. If we head back to our cart page at [`http://localhost:4000/cart`](http://localhost:4000/cart) and complete an order, we'll be greeted by our rendered template: ```text Thank you for your order! User uuid: 08964c7c-908c-4a55-bcd3-9811ad8b0b9d Title Quantity Price Metaprogramming Elixir 2 $15.00 Total price: $30.00 ``` We haven't added payments, but we can already see how our `ShoppingCart` and `Orders` context splitting is driving us towards a maintainable solution. With our cart items separated from our order line items, we are well equipped in the future to add payment transactions, cart price detection, and more. Great work! ================================================ FILE: guides/data_modelling/your_first_context.md ================================================ # 2. Your First Context An ecommerce platform has wide-reaching coupling across a codebase so it's important to think about writing well-defined modules. With that in mind, our goal is to build a product catalog API that handles creating, updating, and deleting the products available in our system. We'll start off with the basic features of showcasing our products, and we will add shopping cart features later. We'll see how starting with a solid foundation with isolated boundaries allows us to grow our application naturally as we add functionality. Phoenix includes the `mix phx.gen.html`, `mix phx.gen.json`, `mix phx.gen.live`, and `mix phx.gen.context` generators that apply the ideas of isolating functionality in our applications into contexts. These generators are a great way to hit the ground running while Phoenix nudges you in the right direction to grow your application. Let's put these tools to use for our new product catalog context. When we run the generators, the context name is optional, and Phoenix will automatically use the plural name as the context module. This allows us to keep moving forward when starting out or when it is not yet clear how the different parts of our system relate to each other. Luckily, the needs of ecommerce systems are well defined nowadays, so it provides an excellent ground for us to design with intent. So let's take a step back and think about the different parts of our system. We know that we'll have products to showcase on pages for sale, along with descriptions, pricing, etc. Along with selling products, we know we'll need to support carting, order checkout, and so on. While the products being purchased are related to the cart and checkout processes, showcasing a product and managing the *exhibition* of our products is distinctly different than tracking what a user has placed in their cart or how an order is placed. A `Catalog` context is a natural place for the management of our product details and the showcasing of those products we have for sale. ## Starting with generators To jump-start our catalog context, we'll use `mix phx.gen.html` which creates a context module that wraps up Ecto access for creating, updating, and deleting products, along with web files like controllers and templates for the web interface into our context. Run the following command at your project root: ```console $ mix phx.gen.html Catalog Product products title:string \ description:string price:decimal views:integer ``` After executing the command, you should see output similar to the following: ```console * creating lib/hello_web/controllers/product_controller.ex * creating lib/hello_web/controllers/product_html/edit.html.heex * creating lib/hello_web/controllers/product_html/index.html.heex * creating lib/hello_web/controllers/product_html/new.html.heex * creating lib/hello_web/controllers/product_html/show.html.heex * creating lib/hello_web/controllers/product_html/product_form.html.heex * creating lib/hello_web/controllers/product_html.ex * creating test/hello_web/controllers/product_controller_test.exs * creating lib/hello/catalog/product.ex * creating priv/repo/migrations/20250201185747_create_products.exs * creating lib/hello/catalog.ex * injecting lib/hello/catalog.ex * creating test/hello/catalog_test.exs * injecting test/hello/catalog_test.exs * creating test/support/fixtures/catalog_fixtures.ex * injecting test/support/fixtures/catalog_fixtures.ex Add the resource to your browser scope in lib/hello_web/router.ex: resources "/products", ProductController Remember to update your repository by running migrations: $ mix ecto.migrate ``` Phoenix generated the web files as expected in `lib/hello_web/`. We can also see our context functions were generated inside a `lib/hello/catalog.ex` file and our product schema file is placed in the directory of the same name. Note the difference between `lib/hello` and `lib/hello_web`. We have a `Catalog` module to serve as the public API for product catalog functionality, as well as a `Catalog.Product` struct, which is an Ecto schema for casting and validating product data. Phoenix also provided web and context tests for us, it also included test helpers for creating entities via the `Hello.Catalog` context, which we'll look at later. For now, let's follow the instructions and add the route according to the console instructions, in `lib/hello_web/router.ex`: ```diff scope "/", HelloWeb do pipe_through :browser get "/", PageController, :index + resources "/products", ProductController end ``` With the new route in place, Phoenix reminds us to update our repo by running `mix ecto.migrate`, but first we need to make a few tweaks to the generated migration in `priv/repo/migrations/*_create_products.exs`: ```diff def change do create table(:products) do add :title, :string add :description, :string - add :price, :decimal + add :price, :decimal, precision: 15, scale: 6, null: false - add :views, :integer + add :views, :integer, default: 0, null: false timestamps(type: :utc_datetime) end ``` We modified our price column to a specific precision of 15, scale of 6, along with a not-null constraint. This ensures we store currency with proper precision for any mathematical operations we may perform. Next, we added a default value and not-null constraint to our views count. With our changes in place, we're ready to migrate up our database. Let's do that now: ```console $ mix ecto.migrate 14:09:02.260 [info] == Running 20250201185747 Hello.Repo.Migrations.CreateProducts.change/0 forward 14:09:02.262 [info] create table products 14:09:02.273 [info] == Migrated 20250201185747 in 0.0s ``` Before we jump into the generated code, let's start the server with `mix phx.server` and visit [http://localhost:4000/products](http://localhost:4000/products). Let's follow the "New Product" link and click the "Save" button without providing any input. When we submit the form, we can see all the validation errors inline with the inputs. Nice! Out of the box, the context generator included the schema fields in our form template and we can see our default validations for required inputs are in effect. Let's enter some example product data and resubmit the form: ```text Product created successfully. Title: Metaprogramming Elixir Description: Write Less Code, Get More Done (and Have Fun!) Price: 15.000000 Views: 0 ``` If we follow the "Back" link, we get a list of all products, which should contain the one we just created. Likewise, we can update this record or delete it. Now that we've seen how it works in the browser, it's time to take a look at the generated code. > #### Naming things is hard {: .tip} > > When starting a web application, it may be hard to draw lines or name its different contexts, especially when the business domain you are working with is not as well established as ecommerce. > > For those reasons, Phoenix generators allow you to skip the context name, which is really helpful when you're stuck or still exploring your business domain. For example, our code above would work the same if we used the default `Products` context for managing products and it would still allow us to organically discover other resources that belong to the `Products` context, such as categories or image galleries. > > We also advise against being too smart when naming your contexts. Pick a name that is clear and obvious to everyone who works (and might work) in the project. As your application grows and the different parts of your system become clear, you can simply rename the context or move resources around. The beauty of Elixir modules is moving them around should be simply a matter of renaming the module names and their callers (and renaming the files for consistency). ## Grokking generated code That little `mix phx.gen.html` command packed a surprising punch. We got a lot of functionality out-of-the-box for creating, updating, and deleting products in our catalog. This is far from a full-featured app, but remember, generators are first and foremost learning tools and a starting point for you to begin building real features. Code generation can't solve all your problems, but it will teach you the ins and outs of Phoenix and nudge you towards the proper mindset when designing your application. Let's first check out the `ProductController` that was generated in `lib/hello_web/controllers/product_controller.ex`: ```elixir defmodule HelloWeb.ProductController do use HelloWeb, :controller alias Hello.Catalog alias Hello.Catalog.Product def index(conn, _params) do products = Catalog.list_products() render(conn, :index, products: products) end def new(conn, _params) do changeset = Catalog.change_product(%Product{}) render(conn, :new, changeset: changeset) end def create(conn, %{"product" => product_params}) do case Catalog.create_product(product_params) do {:ok, product} -> conn |> put_flash(:info, "Product created successfully.") |> redirect(to: ~p"/products/#{product}") {:error, %Ecto.Changeset{} = changeset} -> render(conn, :new, changeset: changeset) end end def show(conn, %{"id" => id}) do product = Catalog.get_product!(id) render(conn, :show, product: product) end ... end ``` We've seen how controllers work in our [controller guide](controllers.html), so the code probably isn't too surprising. What is worth noticing is how our controller calls into the `Catalog` context. We can see that the `index` action fetches a list of products with `Catalog.list_products/0`, and how products are persisted in the `create` action with `Catalog.create_product/1`. We haven't yet looked at the catalog context, so we don't yet know how product fetching and creation is happening under the hood – *but that's the point*. Our Phoenix controller is the web interface into our greater application. It shouldn't be concerned with the details of how products are fetched from the database or persisted into storage. We only care about telling our application to perform some work for us. This is great because our business logic and storage details are decoupled from the web layer of our application. If we move to a full-text storage engine later for fetching products instead of a SQL query, our controller doesn't need to be changed. Likewise, we can reuse our context code from any other interface in our application, be it a channel, mix task, or long-running process importing CSV data. In the case of our `create` action, when we successfully create a product, we use `Phoenix.Controller.put_flash/3` to show a success message, and then we redirect to the router's product show page. Conversely, if `Catalog.create_product/1` fails, we render our `"new.html"` template and pass along the Ecto changeset for the template to lift error messages from. Next, let's dig deeper and check out our `Catalog` context in `lib/hello/catalog.ex`: ```elixir defmodule Hello.Catalog do @moduledoc """ The Catalog context. """ import Ecto.Query, warn: false alias Hello.Repo alias Hello.Catalog.Product @doc """ Returns the list of products. ## Examples iex> list_products() [%Product{}, ...] """ def list_products do Repo.all(Product) end ... end ``` This module will be the public API for all product catalog functionality in our system. For example, in addition to product detail management, we may also handle product category classification and product variants for things like optional sizing, trims, etc. If we look at the `list_products/0` function, we can see the private details of product fetching. And it's super simple. We have a call to `Repo.all(Product)`. We saw how Ecto repo queries worked in the [Ecto guide](ecto.html), so this call should look familiar. Our `list_products` function is a generalized function name specifying the *intent* of our code – namely to list products. The details of that intent where we use our Repo to fetch the products from our PostgreSQL database, are hidden from our callers. This is a common theme we'll see reiterated as we use the Phoenix generators. Phoenix will push us to think about where we have different responsibilities in our application, and then to wrap up those different areas behind well-named modules and functions that make the intent of our code clear, while encapsulating the details. Now we know how data is fetched, but how are products persisted? Let's take a look at the `Catalog.create_product/1` function: ```elixir @doc """ Creates a product. ## Examples iex> create_product(%{field: value}) {:ok, %Product{}} iex> create_product(%{field: bad_value}) {:error, %Ecto.Changeset{}} """ def create_product(attrs) do %Product{} |> Product.changeset(attrs) |> Repo.insert() end ``` There's more documentation than code here, but a couple of things are important to highlight. First, we can see again that our Ecto Repo is used under the hood for database access. You probably also noticed the call to `Product.changeset/2`. We talked about changesets before, and now we see them in action in our context. If we open up the `Product` schema in `lib/hello/catalog/product.ex`, it will look immediately familiar: ```elixir defmodule Hello.Catalog.Product do use Ecto.Schema import Ecto.Changeset schema "products" do field :description, :string field :price, :decimal field :title, :string field :views, :integer timestamps(type: :utc_datetime) end @doc false def changeset(product, attrs) do product |> cast(attrs, [:title, :description, :price, :views]) |> validate_required([:title, :description, :price, :views]) end end ``` This is just what we saw before when we ran `mix phx.gen.schema`, except here we see a `@doc false` above our `changeset/2` function. This tells us that while this function is publicly callable, it's not part of the public context API. Callers that build changesets do so via the context API. For example, `Catalog.create_product/1` calls into our `Product.changeset/2` to build the changeset from user input. Callers, such as our controller actions, do not access `Product.changeset/2` directly. All interaction with our product changesets is done through the public `Catalog` context. ## Adding Catalog functions As we've seen, your context modules are dedicated modules that expose and group related functionality. Phoenix generates generic functions, such as `list_products` and `update_product`, but they only serve as a basis for you to grow your business logic and application from. Let's add one of the basic features of our catalog by tracking product page view count. For any ecommerce system, the ability to track how many times a product page has been viewed is essential for marketing, suggestions, ranking, etc. While we could try to use the existing `Catalog.update_product` function, along the lines of `Catalog.update_product(product, %{views: product.views + 1})`, this would not only be prone to race conditions, but it would also require the caller to know too much about our Catalog system. To see why the race condition exists, let's walk through the possible execution of events: Intuitively, you would assume the following events: 1. User 1 loads the product page with count of 13 2. User 1 saves the product page with count of 14 3. User 2 loads the product page with count of 14 4. User 2 saves the product page with count of 15 While in practice this would happen: 1. User 1 loads the product page with count of 13 2. User 2 loads the product page with count of 13 3. User 1 saves the product page with count of 14 4. User 2 saves the product page with count of 14 The race conditions would make this an unreliable way to update the existing table since multiple callers may be updating out of date view values. There's a better way. Let's think of a function that describes what we want to accomplish. Here's how we would like to use it: ```elixir product = Catalog.inc_page_views(product) ``` That looks great. Our callers will have no confusion over what this function does, and we can wrap up the increment in an atomic operation to prevent race conditions. Open up your catalog context (`lib/hello/catalog.ex`), and add this new function: ```elixir def inc_page_views(%Product{} = product) do {1, [%Product{views: views}]} = from(p in Product, where: p.id == ^product.id, select: [:views]) |> Repo.update_all(inc: [views: 1]) put_in(product.views, views) end ``` We built a query for fetching the current product given its ID which we pass to `Repo.update_all`. Ecto's `Repo.update_all` allows us to perform batch updates against the database, and is perfect for atomically updating values, such as incrementing our views count. The result of the repo operation returns the number of updated records, along with the selected schema values specified by the `select` option. When we receive the new product views, we use `put_in(product.views, views)` to place the new view count within the product struct. With our context function in place, let's make use of it in our product controller. Update your `show` action in `lib/hello_web/controllers/product_controller.ex` to call our new function: ```elixir def show(conn, %{"id" => id}) do product = id |> Catalog.get_product!() |> Catalog.inc_page_views() render(conn, :show, product: product) end ``` We modified our `show` action to pipe our fetched product into `Catalog.inc_page_views/1`, which will return the updated product. Then we rendered our template just as before. Let's try it out. Refresh one of your product pages a few times and watch the view count increase. We can also see our atomic update in action in the ecto debug logs: ```text [debug] QUERY OK source="products" db=0.5ms idle=834.5ms UPDATE "products" AS p0 SET "views" = p0."views" + $1 WHERE (p0."id" = $2) RETURNING p0."views" [1, 1] ``` Good work! As we've seen, designing with contexts gives you a solid foundation to grow your application from. Using discrete, well-defined APIs that expose the intent of your system allows you to write more maintainable applications with reusable code. Now that we know how to start extending our context API, let's explore handling relationships within a context. ================================================ FILE: guides/deployment/deployment.md ================================================ # Introduction to Deployment Once we have a working application, we're ready to deploy it. If you're not quite finished with your own application, don't worry. Just follow the [Up and Running Guide](up_and_running.html) to create a basic application to work with. When preparing an application for deployment, there are three main steps: * Handling of your application secrets * Compiling your application assets * Starting your server in production In this guide, we will learn how to get the production environment running locally. You can use the same techniques in this guide to run your application in production, but depending on your deployment infrastructure, extra steps will be necessary. As an example of deploying to other infrastructures, we also discuss four different approaches in our guides: using [Elixir's releases](releases.html) with `mix release`, [using Gigalixir](gigalixir.html), [using Fly](fly.html), and [using Heroku](heroku.html). We've also included links to deploying Phoenix on other platforms under [Community Deployment Guides](#community-deployment-guides). Finally, the release guide has a sample Dockerfile you can use if you prefer to deploy with container technologies. Let's explore those steps above one by one. ## Handling of your application secrets All Phoenix applications have data that must be kept secure, for example, the username and password for your production database, and the secret Phoenix uses to sign and encrypt important information. The general recommendation is to keep those in environment variables and load them into your application. This is done in `config/runtime.exs` (formerly `config/prod.secret.exs` or `config/releases.exs`), which is responsible for loading secrets and configuration from environment variables at boot time. Therefore, you need to make sure the proper relevant variables are set in production: ```console $ mix phx.gen.secret REALLY_LONG_SECRET $ export SECRET_KEY_BASE=REALLY_LONG_SECRET $ export DATABASE_URL=ecto://USER:PASS@HOST/database ``` Do not copy those values directly, set `SECRET_KEY_BASE` according to the result of `mix phx.gen.secret` and `DATABASE_URL` according to your database address. If for some reason you do not want to rely on environment variables, you can hard code the secrets in your `config/runtime.exs` but make sure not to check the file into your version control system. With your secret information properly secured, it is time to configure assets! Before taking this step, we need to do one bit of preparation. Since we will be readying everything for production, we need to do some setup in that environment by getting our dependencies and compiling. ```console $ mix deps.get --only prod $ MIX_ENV=prod mix compile ``` ## Compiling your application assets This step is required only if you have compilable assets like JavaScript and stylesheets. By default, Phoenix uses `esbuild` but everything is encapsulated in a single `mix assets.deploy` task defined in your `mix.exs`: ```console $ MIX_ENV=prod mix assets.deploy Check your digested files at "priv/static". ``` And that is it! The Mix task by default builds the assets and then generates digests with a cache manifest file so Phoenix can quickly serve assets in production. > Note: if you run the task above in your local machine, it will generate many digested assets in `priv/static`. You can prune them by running `mix phx.digest.clean --all`. Keep in mind that, if you by any chance forget to run the steps above, Phoenix will show an error message: ```console $ PORT=4001 MIX_ENV=prod mix phx.server 10:50:18.732 [info] Running MyAppWeb.Endpoint with Cowboy on http://example.com 10:50:18.735 [error] Could not find static manifest at "my_app/_build/prod/lib/foo/priv/static/cache_manifest.json". Run "mix phx.digest" after building your static files or remove the configuration from "config/prod.exs". ``` The error message is quite clear: it says Phoenix could not find a static manifest. Just run the commands above to fix it or, if you are not serving or don't care about assets at all, you can just remove the `cache_static_manifest` configuration from your config. ## Starting your server in production To run Phoenix in production, we need to set the `PORT` and `MIX_ENV` environment variables when invoking `mix phx.server`: ```console $ PORT=4001 MIX_ENV=prod mix phx.server 10:59:19.136 [info] Running MyAppWeb.Endpoint with Cowboy on http://example.com ``` To run in detached mode so that the Phoenix server does not stop and continues to run even if you close the terminal: ```console $ PORT=4001 MIX_ENV=prod elixir --erl "-detached" -S mix phx.server ``` In case you get an error message, please read it carefully, and open up a bug report if it is still not clear how to address it. You can also run your application inside an interactive shell: ```console $ PORT=4001 MIX_ENV=prod iex -S mix phx.server 10:59:19.136 [info] Running MyAppWeb.Endpoint with Cowboy on http://example.com ``` ## Putting it all together The previous sections give an overview about the main steps required to deploy your Phoenix application. In practice, you will end-up adding steps of your own as well. For example, if you are using a database, you will also want to run `mix ecto.migrate` before starting the server to ensure your database is up to date. Overall, here is a script you can use as a starting point: ```console # Initial setup $ mix deps.get --only prod $ MIX_ENV=prod mix compile # Compile assets $ MIX_ENV=prod mix assets.deploy # Custom tasks (like DB migrations) $ MIX_ENV=prod mix ecto.migrate # Finally run the server $ PORT=4001 MIX_ENV=prod mix phx.server ``` And that's it. Next, you can use one of our official guides to deploy: * [with Elixir's releases](releases.html) * [to Gigalixir](gigalixir.html), an Elixir-centric Platform as a Service (PaaS) * [to Fly.io](fly.html), a PaaS that deploys your servers close to your users with built-in distribution support * and [to Heroku](heroku.html), one of the most popular PaaS. ## Clustering and Long-Polling Transports Phoenix supports two types of transports for its Socket implementation: WebSocket, and Long-Polling. When generating a Phoenix project, you can see the default configuration set in the generated `endpoint.ex` file: ```elixir socket "/live", Phoenix.LiveView.Socket, websocket: [connect_info: [session: @session_options]], longpoll: [connect_info: [session: @session_options]] ``` This configuration tells Phoenix that both the WebSocket and the Long-Polling options are available, and based on the client's network conditions, Phoenix will first attempt to connect to the WebSocket, falling back to the Long-Poll option after the configured timeout found in the generated `app.js` file: ```javascript let liveSocket = new LiveSocket("/live", Socket, { longPollFallbackMs: 2500, params: {_csrf_token: csrfToken} }) ``` If you are running more than one machine in production, which is the recommended approach in most cases, this automatic fallback comes with an important caveat. If you want Long-Polling to work properly, your application must either: 1. Utilize the Erlang VM's clustering capabilities, so the default `Phoenix.PubSub` adapter can broadcast messages across nodes 2. Choose a different `Phoenix.PubSub` adapter (such as `Phoenix.PubSub.Redis`) 3. Or your deployment option must implement sticky sessions - ensuring that all requests for a specific session go to the same machine The reason for this is simple. While a WebSocket is a long-lived open connection to the same machine, long-polling works by opening a request to the server, waiting for a timeout or until the open request is fulfilled, and repeating this process. In order to preserve the state of the user's connected socket and to preserve the behaviour of a socket being long-lived, the user's process is kept alive, and each long-poll request attempts to find the user's stateful process. If the stateful process is not reachable, every request will create a new process and a new state, thereby breaking the fact that the socket is long-lived and stateful. ## Community Deployment Guides * [Render](https://render.com) has first class support for Phoenix applications. There are guides for hosting Phoenix with [Mix releases](https://render.com/docs/deploy-phoenix) and as a [Distributed Elixir Cluster](https://render.com/docs/deploy-elixir-cluster). * [Railway](https://railway.com) also provides support for Phoenix applications using [Mix releases](https://docs.railway.com/guides/phoenix). ================================================ FILE: guides/deployment/fly.md ================================================ # Deploying on Fly.io The main goal for this guide is to get a Phoenix application running on [Fly.io](https://fly.io). Fly.io maintains their own guide for Elixir/Phoenix here: [Fly.io/docs/elixir/getting-started/](https://fly.io/docs/elixir/getting-started/). We will keep this guide up but for the latest and greatest check with them! ## What we'll need The only thing we'll need for this guide is a working Phoenix application. For those of us who need a simple application to deploy, please follow the [Up and Running guide](https://hexdocs.pm/phoenix/up_and_running.html). You can just: ```console $ mix phx.new my_app ``` ## Sections Let's separate this process into a few steps, so we can keep track of where we are. - Install the Fly.io CLI - Sign up for Fly.io - Deploy the app to Fly.io - Clustering your application - Extra Fly.io tips - Helpful Fly.io resources ## Installing the Fly.io CLI Follow the instructions [here](https://fly.io/docs/getting-started/installing-flyctl/) to install Flyctl, the command-line interface for the Fly.io platform. ## Sign up for Fly.io We can [sign up for an account](https://fly.io/docs/getting-started/log-in-to-fly/) using the CLI. ```console $ fly auth signup ``` Or sign in. ```console $ fly auth login ``` Fly has a [free tier](https://fly.io/docs/about/pricing/) for most applications. A credit card is required when setting up an account to help prevent abuse. See the [pricing](https://fly.io/docs/about/pricing/) page for more details. ## Deploy the app to Fly.io To tell Fly about your application, run `fly launch` in the directory with your source code. This creates and configures a Fly.io app. ```console $ fly launch ``` This scans your source, detects the Phoenix project, and runs `mix phx.gen.release --docker` for you! This creates a Dockerfile for you. The `fly launch` command walks you through a few questions. - You can name the app or have it generate a random name for you. - Choose an organization (defaults to `personal`). Organizations are a way of sharing applications and resources between Fly.io users. - Choose a region to deploy to. Defaults to the nearest Fly.io region. You can check out the [complete list of regions here](https://fly.io/docs/reference/regions/). - Sets up a Postgres DB for you. - Builds the Dockerfile. - Deploys your application! The `fly launch` command also created a `fly.toml` file for you. This is where you can set ENV values and other config. ### Storing secrets on Fly.io You may also have some secrets you'd like to set on your app. Use [`fly secrets`](https://fly.io/docs/reference/secrets/#setting-secrets) to configure those. ```console $ fly secrets set MY_SECRET_KEY=my_secret_value ``` ### Deploying again When you want to deploy changes to your application, use `fly deploy`. ```console $ fly deploy ``` Note: On Apple Silicon (M1) computers, docker runs cross-platform builds using qemu which might not always work. If you get a segmentation fault error like the following: ```console => [build 7/17] RUN mix deps.get --only => => # qemu: uncaught target signal 11 (Segmentation fault) - core dumped ``` You can use fly's remote builder by adding the `--remote-only` flag: ```console $ fly deploy --remote-only ``` You can always check on the status of a deploy ```console $ fly status ``` Check your app logs ```console $ fly logs ``` If everything looks good, open your app on Fly ```console $ fly open ``` ## Clustering your application Elixir and the Erlang VM have the incredible ability to be clustered together and pass messages seamlessly between nodes. Phoenix comes with all of the knobs in place, you only need to set the appropriate environment variables before deploying. If you used `fly launch` to deploy your app, those environment variables are already in place, if not, open up `rel/env.ssh.eex` and add: ```sh export ERL_AFLAGS="-proto_dist inet6_tcp" export RELEASE_DISTRIBUTION="name" export RELEASE_NODE="${FLY_APP_NAME}-${FLY_IMAGE_REF##*-}@${FLY_PRIVATE_IP}" export ECTO_IPV6="true" export DNS_CLUSTER_QUERY="${FLY_APP_NAME}.internal" ``` The first three environment variables are managed by Elixir and the Erlang/VM: * `ERL_AFLAGS` - configures Erlang to use IPv6 for its distribution * `RELEASE_DISTRIBUTION` - configures Erlang to named nodes * `RELEASE_NODE` - attaches a name to the node, using Fly's app name and deploy reference The last two are handled by your `config/runtime.exs`: * `ECTO_IPV6` - connect to the database using IPv6 * `DNS_CLUSTER_QUERY` - configures your app to find other nodes using the given DNS query ## Extra Fly.io tips ### Getting an IEx shell into a running node Elixir supports getting a IEx shell into a running production node. There are a couple prerequisites, we first need to establish an [SSH Shell](https://fly.io/docs/flyctl/ssh/) to our machine on Fly.io. This step sets up a root certificate for your account and then issues a certificate. ```console $ fly ssh issue --agent ``` With SSH configured, let's open a console. ```console $ fly ssh console Connecting to my-app-1234.internal... complete / # ``` If all has gone smoothly, then you have a shell into the machine! Now we just need to launch our remote IEx shell. The deployment Dockerfile was configured to pull our application into `/app`. So the command for an app named `my_app` looks like this: ```console $ app/bin/my_app remote Erlang/OTP 23 [erts-11.2.1] [source] [64-bit] [smp:1:1] [ds:1:1:10] [async-threads:1] Interactive Elixir (1.11.2) - press Ctrl+C to exit (type h() ENTER for help) iex(my_app@fdaa:0:1da8:a7b:ac4:b204:7e29:2)1> ``` Now we have a running IEx shell into our node! You can safely disconnect using CTRL+C, CTRL+C. #### Running multiple instances There are two ways to run multiple instances. 1. Scale our application to have multiple instances in one region. 2. Add an instance to another region (multiple regions). Let's first start with a baseline of our single deployment. ```console $ fly status ... Instances ID VERSION REGION DESIRED STATUS HEALTH CHECKS RESTARTS CREATED f9014bf7 26 sea run running 1 total, 1 passing 0 1h8m ago ``` #### Scaling in a single region Let's scale up to 2 instances in our current region. ```console $ fly scale count 2 Count changed to 2 ``` Checking the status, we can see what happened. ```console $ fly status ... Instances ID VERSION REGION DESIRED STATUS HEALTH CHECKS RESTARTS CREATED eb4119d3 27 sea run running 1 total, 1 passing 0 39s ago f9014bf7 27 sea run running 1 total, 1 passing 0 1h13m ago ``` We now have two instances in the same region. Let's make sure they are clustered together. From an IEx shell, we can ask the node we're connected to, what other nodes it can see. ```console $ fly ssh console -C "/app/bin/my_app remote" ``` ```elixir iex(my-app-1234@fdaa:0:1da8:a7b:ac2:f901:4bf7:2)1> Node.list [:"my-app-1234@fdaa:0:1da8:a7b:ac4:eb41:19d3:2"] ``` The IEx prompt is included to help show the IP address of the node we are connected to. Then getting the `Node.list` returns the other node. Our two instances are connected and clustered! #### Scaling to multiple regions Fly makes it easy to deploy instances closer to your users. Through the magic of DNS, users are directed to the nearest region where your application is located. You can read more about [Fly.io regions here](https://fly.io/docs/reference/regions/). Starting back from our baseline of a single instance running in `sea` which is Seattle, Washington (US), let's add the region `ewr` which is Parsippany, NJ (US). This puts an instance on both coasts of the US. ```console $ fly regions add ewr Region Pool: ewr sea Backup Region: iad lax sjc vin ``` Looking at the status shows that we're only in 1 region because our count is set to 1. ```console $ fly status ... Instances ID VERSION REGION DESIRED STATUS HEALTH CHECKS RESTARTS CREATED cdf6c422 29 sea run running 1 total, 1 passing 0 58s ago ``` Let's add a 2nd instance and see it deploy to `ewr`. ```console $ fly scale count 2 Count changed to 2 ``` Now the status shows we have two instances spread across 2 regions! ```console $ fly status ... Instances ID VERSION REGION DESIRED STATUS HEALTH CHECKS RESTARTS CREATED 0a8e6666 30 ewr run running 1 total, 1 passing 0 16s ago cdf6c422 30 sea run running 1 total, 1 passing 0 6m47s ago ``` Let's ensure they are clustered together. ```console $ fly ssh console -C "/app/bin/my_app remote" ``` ```elixir iex(my-app-1234@fdaa:0:1da8:a7b:ac2:cdf6:c422:2)1> Node.list [:"my-app-1234@fdaa:0:1da8:a7b:ab2:a8e:6666:2"] ``` We have two instances of our application deployed to the West and East coasts of the North American continent and they are clustered together! Our users will automatically be directed to the server nearest them. The Fly.io platform has built-in distribution support making it easy to cluster distributed Elixir nodes in multiple regions. ## Helpful Fly.io resources Open the Dashboard for your account ```console $ fly dashboard ``` Deploy your application ```console $ fly deploy ``` Show the status of your deployed application ```console $ fly status ``` Access and tail the logs ```console $ fly logs ``` Scaling your application up or down ```console $ fly scale count 2 ``` Refer to the [Fly.io Elixir documentation](https://fly.io/docs/getting-started/elixir) for additional information. [The Fly.io docs](https://fly.io/docs/) covers things like: * [Status](https://fly.io/docs/flyctl/status/) and [logs](https://fly.io/docs/monitoring/logging-overview/) * [Custom domains](https://fly.io/docs/networking/custom-domain/) * [Certificates](https://fly.io/docs/networking/custom-domain-api/) ## Troubleshooting See [Troubleshooting](https://fly.io/docs/getting-started/troubleshooting/) and [Elixir Troubleshooting](https://fly.io/docs/elixir/the-basics/troubleshooting/) Visit the [Fly.io Community](https://community.fly.io/) to find solutions and ask questions. ================================================ FILE: guides/deployment/gigalixir.md ================================================ # Deploying on Gigalixir Our main goal for this guide is to get a Phoenix application running on Gigalixir. ## What we'll need The only thing we'll need for this guide is a working Phoenix application. For those of us who need a simple application to deploy, please follow the [Up and Running guide](https://hexdocs.pm/phoenix/up_and_running.html). ## Steps Let's separate this process into a few steps, so we can keep track of where we are. - Initialize Git repository - Install the Gigalixir CLI - Sign up for Gigalixir - Create and set up Gigalixir application - Provision a database - Make our project ready for Gigalixir - Deploy time! - Useful Gigalixir commands ## Initializing Git repository If you haven't already, we'll need to commit our files to git. We can do so by running the following commands in our project directory: ```console $ git init $ git add . $ git commit -m "Initial commit" ``` ## Installing the Gigalixir CLI Follow the instructions [here](https://gigalixir.com/docs/getting-started-guide/) to install the command-line interface for your platform. ## Signing up for Gigalixir We can sign up for an account at [gigalixir.com](https://gigalixir.com) or with the CLI. Let's use the CLI. ```console $ gigalixir signup # or with a Google account $ gigalixir signup:google ``` Gigalixir’s free tier does not require a credit card and comes with 1 app instance and 1 PostgreSQL database for free, but please consider upgrading to a paid plan if you are running a production application. Next, let's login ```console $ gigalixir login # or with a Google account $ gigalixir login:google ``` And verify ```console $ gigalixir account ``` ## Creating and setting up our Gigalixir application There are two different ways to deploy a Phoenix app on Gigalixir: with mix or with Elixir's releases. In this guide, we'll be using Elixir's releases because it is the recommended way. For more information, see [Elixir Releases vs Mix](https://gigalixir.com/docs/modify-app/#elixir-releases-vs-mix). If you want to deploy with the mix method, follow the [Phoenix deploy with Mix Guide](https://gigalixir.com/docs/getting-started-guide/phoenix-mix-deploy). ### Creating a Gigalixir application Let's create a Gigalixir application ```console $ gigalixir create -n "your-app-name" ``` Note: the app name cannot be changed afterwards. A random name is used if you do not provide one. ### Specifying versions Gigalixir requires that you specify the Erlang and Elixir versions you intend to use. It's generally a good idea to run the same version in production as you do in development. For example: ```console $ echo 'elixir_version=1.17.2' > elixir_buildpack.config $ echo 'erlang_version=27.0' >> elixir_buildpack.config $ git add elixir_buildpack.config ``` Gigalixir will use the latest nodejs version if you do not specify a version. If you want to specify your nodejs version, you can do so like this: ```console $ echo 'node_version=22.7.0' > phoenix_static_buildpack.config $ git add elixir_buildpack.config phoenix_static_buildpack.config assets/package.json ``` Finally, don't forget to commit: ```console $ git commit -m "Set versions" ``` ## Provisioning a database Let's provision a database for our app. For a free database, run the following command ```console $ gigalixir pg:create --free ``` For a production ready database, be sure to upgrade your account to the Standard Tier and create a Standard tier database ```console $ gigalixir account:upgrade $ gigalixir pg:create ``` Verify the database was created ```console $ gigalixir pg ``` Verify that a `DATABASE_URL` and `POOL_SIZE` were created ```console $ gigalixir config ``` ## Making our Project ready for Gigalixir There's nothing we need to do to get our app running on Gigalixir, but for a production app, you probably want to enforce SSL. ### Database Connection Security You may also want to use SSL for your database connection. In your `config/runtime.exs`: ```elixir ssl: [ verify: :verify_peer, cacerts: :public_key.cacerts_get() ] ``` ## Deploy Time! Our project is now ready to be deployed on Gigalixir. Be sure you have everything committed to git and run the following command: ```console $ git push gigalixir ``` Check the status of your deploy and wait until the app is `Healthy` ```console $ gigalixir ps ``` Run migrations ```console $ gigalixir ps:migrate ``` Check your app logs ```console $ gigalixir logs ``` If everything looks good, let's take a look at your app running on Gigalixir ```console $ gigalixir open ``` ## Useful Gigalixir Commands Open a remote console ```console $ gigalixir account:ssh_keys:add "$(cat ~/.ssh/id_rsa.pub)" $ gigalixir ps:remote_console ``` To set up clustering, see [Clustering Nodes](https://gigalixir.com/docs/cluster) For custom domains, scaling, jobs and other features, see the [Gigalixir Documentation](https://gigalixir.com/docs/). ## Troubleshooting See [Troubleshooting](https://gigalixir.com/docs/troubleshooting) and the [FAQ](https://gigalixir.com/docs/faq) Also, don't hesitate to email [help@gigalixir.com](mailto:help@gigalixir.com) or [request an invitation](https://elixir-lang.slack.com/join/shared_invite/zt-1f13hz7mb-N4KGjF523ONLCcHfb8jYgA#/shared-invite/email) and join the #gigalixir channel on [Slack](https://elixir-lang.slack.com). ================================================ FILE: guides/deployment/heroku.md ================================================ # Deploying on Heroku Our main goal for this guide is to get a Phoenix application running on Heroku. ## What we'll need The only thing we'll need for this guide is a working Phoenix application. For those of us who need a simple application to deploy, please follow the [Up and Running guide](https://hexdocs.pm/phoenix/up_and_running.html). ## Limitations Heroku is a great platform and Elixir performs well on it. However, you may run into limitations if you plan to leverage advanced features provided by Elixir and Phoenix, such as: - Connections are limited. - Heroku [limits the number of simultaneous connections](https://devcenter.heroku.com/articles/http-routing#request-concurrency) as well as the [duration of each connection](https://devcenter.heroku.com/articles/limits#http-timeouts). It is common to use Elixir for real-time apps which need lots of concurrent, persistent connections, and Phoenix is capable of [handling over 2 million connections on a single server](https://www.phoenixframework.org/blog/the-road-to-2-million-websocket-connections). - Distributed clustering is not possible. - Heroku [firewalls dynos off from one another](https://devcenter.heroku.com/articles/dynos#networking). This means things like [distributed Phoenix channels](https://dockyard.com/blog/2016/01/28/running-elixir-and-phoenix-projects-on-a-cluster-of-nodes) and [distributed tasks](https://hexdocs.pm/elixir/distributed-tasks.html) will need to rely on something like Redis instead of Elixir's built-in distribution. - In-memory state such as those in [Agents](https://hexdocs.pm/elixir/agents.html), [GenServers](https://hexdocs.pm/elixir/genservers.html), and [ETS](https://hexdocs.pm/elixir/erlang-term-storage.html) will be lost every 24 hours. - Heroku [restarts dynos](https://devcenter.heroku.com/articles/dynos#restarting) every 24 hours regardless of whether the node is healthy. - [The built-in observer](https://hexdocs.pm/elixir/debugging.html#observer) can't be used with Heroku. - Heroku does allow for connection into your dyno, but you won't be able to use the observer to watch the state of your dyno. If you are just getting started, or you don't expect to use the features above, Heroku should be enough for your needs. For instance, if you are migrating an existing application running on Heroku to Phoenix, keeping a similar set of features, Elixir will perform just as well or even better than your current stack. If you want a platform-as-a-service without these limitations, there are alternatives listed in the sidebar and also generally available elsewhere. If you would rather deploy to a cloud platform, such as EC2, Google Cloud, etc, consider using `mix release`. ## Steps Let's separate this process into a few steps, so we can keep track of where we are. - Initialize Git repository - Sign up for Heroku - Install the Heroku Toolbelt - Create and set up Heroku application - Make our project ready for Heroku - Deploy time! - Useful Heroku commands ## Initializing Git repository [Git](https://git-scm.com/) is a popular decentralized revision control system and is also used to deploy apps to Heroku. Before we can push to Heroku, we'll need to initialize a local Git repository and commit our files to it. We can do so by running the following commands in our project directory: ```console $ git init $ git add . $ git commit -m "Initial commit" ``` Heroku offers some great information on how it is using Git [here](https://devcenter.heroku.com/articles/git#prerequisites-install-git-and-the-heroku-cli). ## Signing up for Heroku Signing up to Heroku is very simple, just head over to [https://signup.heroku.com/](https://signup.heroku.com/) and fill in the form. The Free plan will give us one web [dyno](https://devcenter.heroku.com/articles/dynos) and one worker dyno, as well as a PostgreSQL and Redis instance for free. These are meant to be used for testing and development, and come with some limitations. In order to run a production application, please consider upgrading to a paid plan. ## Installing the Heroku Toolbelt Once we have signed up, we can download the correct version of the Heroku Toolbelt for our system [here](https://toolbelt.heroku.com/). The Heroku CLI, part of the Toolbelt, is useful to create Heroku applications, list currently running dynos for an existing application, tail logs or run one-off commands (mix tasks for instance). ## Create and Set Up Heroku Application There are two different ways to deploy a Phoenix app on Heroku. We could use Heroku buildpacks or their container stack. The difference between these two approaches is in how we tell Heroku to treat our build. In buildpack case, we need to update our apps configuration on Heroku to use Phoenix/Elixir specific buildpacks. On container approach, we have more control on how we want to set up our app, and we can define our container image using `Dockerfile` and `heroku.yml`. This section will explore the buildpack approach. In order to use Dockerfile, it is often recommended to convert our app to use releases, which we will describe later on. ### Create Application A [buildpack](https://devcenter.heroku.com/articles/buildpacks) is a convenient way of packaging framework and/or runtime support. Phoenix requires 2 buildpacks to run on Heroku, the first adds basic Elixir support and the second adds Phoenix specific commands. With the Toolbelt installed, let's create the Heroku application. We will do so using the latest available version of the [Elixir buildpack](https://github.com/HashNuke/heroku-buildpack-elixir): ```console $ heroku create --buildpack hashnuke/elixir Creating app... done, ⬢ mysterious-meadow-6277 Setting buildpack to hashnuke/elixir... done https://mysterious-meadow-6277.herokuapp.com/ | https://git.heroku.com/mysterious-meadow-6277.git ``` > Note: the first time we use a Heroku command, it may prompt us to log in. If this happens, just enter the email and password you specified during signup. > Note: the name of the Heroku application is the random string after "Creating" in the output above (mysterious-meadow-6277). This will be unique, so expect to see a different name from "mysterious-meadow-6277". > Note: the URL in the output is the URL to our application. If we open it in our browser now, we will get the default Heroku welcome page. > Note: if we hadn't initialized our Git repository before we ran the `heroku create` command, we wouldn't have our Heroku remote repository properly set up at this point. We can set that up manually by running: `heroku git:remote -a [our-app-name].` The buildpack uses a predefined Elixir and Erlang version, but to avoid surprises when deploying, it is best to explicitly list the Elixir and Erlang version we want in production to be the same we are using during development or in your continuous integration servers. This is done by creating a config file named `elixir_buildpack.config` in the root directory of your project with your target version of Elixir and Erlang: ```console # Elixir version elixir_version=1.15.0 # Erlang version # https://github.com/HashNuke/heroku-buildpack-elixir-otp-builds/blob/master/otp-versions erlang_version=25.3 # Invoke assets.deploy defined in your mix.exs to deploy assets with esbuild # Note we nuke the esbuild executable from the image hook_post_compile="eval mix assets.deploy && rm -f _build/esbuild*" ``` Finally, let's tell the build pack how to start our webserver. Create a file named `Procfile` at the root of your project: ```console web: mix phx.server ``` ### Optional: Node, npm, and the Phoenix Static buildpack By default, Phoenix uses `esbuild` and manages all assets for you. However, if you are using `node` and `npm`, you will need to install the [Phoenix Static buildpack](https://github.com/gigalixir/gigalixir-buildpack-phoenix-static) to handle them: ```console $ heroku buildpacks:add https://github.com/gigalixir/gigalixir-buildpack-phoenix-static.git Buildpack added. Next release on mysterious-meadow-6277 will use: 1. https://github.com/HashNuke/heroku-buildpack-elixir.git 2. https://github.com/gigalixir/gigalixir-heroku-buildpack-phoenix-static.git ``` When using this buildpack, you want to delegate all asset bundling to `npm`. So you must remove the `hook_post_compile` configuration from your `elixir_buildpack.config` and move it to the deploy script of your `assets/package.json`. Something like this: ```javascript { ... "scripts": { "deploy": "cd .. && mix assets.deploy && rm -f _build/esbuild*" } ... } ``` The Phoenix Static buildpack uses a predefined Node.js version, but to avoid surprises when deploying, it is best to explicitly list the Node.js version we want in production to be the same we are using during development or in your continuous integration servers. This is done by creating a config file named `phoenix_static_buildpack.config` in the root directory of your project with your target version of Node.js: ```text # Node.js version node_version=10.20.1 ``` Please refer to the [configuration section](https://github.com/gigalixir/gigalixir-buildpack-phoenix-static#configuration) for full details. You can make your own custom build script, but for now we will use the [default one provided](https://github.com/gigalixir/gigalixir-buildpack-phoenix-static/blob/master/compile). Finally, note that since we are using multiple buildpacks, you might run into an issue where the sequence is out of order (the Elixir buildpack needs to run before the Phoenix Static buildpack). [Heroku's docs](https://devcenter.heroku.com/articles/using-multiple-buildpacks-for-an-app) explain this better, but you will need to make sure the Phoenix Static buildpack comes last. ## Making our Project ready for Heroku Every new Phoenix project ships with a config file `config/runtime.exs` which loads configuration and secrets from [environment variables](https://devcenter.heroku.com/articles/config-vars). This aligns well with Heroku best practices ([12-factor apps](https://12factor.net/)), so the only work left for us to do is to configure URLs and SSL. First let's tell Phoenix to only use the SSL version of the website. Find the endpoint config in your `config/prod.exs`: ```elixir config :scaffold, ScaffoldWeb.Endpoint, url: [port: 443, scheme: "https"], ``` ... and add `force_ssl` ```elixir config :scaffold, ScaffoldWeb.Endpoint, url: [port: 443, scheme: "https"], force_ssl: [rewrite_on: [:x_forwarded_proto]], ``` `force_ssl` need to be set here because it is a _compile_ time config. It will not work when set from `runtime.exs`. Then in your `config/runtime.exs`: ... add `host` ```elixir config :scaffold, ScaffoldWeb.Endpoint, url: [host: host, port: 443, scheme: "https"] ``` and uncomment the `# ssl: true,` line in your repository configuration. It will look like this: ```elixir config :hello, Hello.Repo, ssl: true, url: database_url, pool_size: String.to_integer(System.get_env("POOL_SIZE") || "10") ``` Finally, if you plan on using websockets, then we will need to decrease the timeout for the websocket transport in `lib/hello_web/endpoint.ex`. If you do not plan on using websockets, then leaving it set to false is fine. You can find further explanation of the options available at the [documentation](https://hexdocs.pm/phoenix/Phoenix.Endpoint.html#socket/3-websocket-configuration). ```elixir defmodule HelloWeb.Endpoint do use Phoenix.Endpoint, otp_app: :hello socket "/socket", HelloWeb.UserSocket, websocket: [timeout: 45_000] ... end ``` Also set the host in Heroku: ```console $ heroku config:set PHX_HOST="mysterious-meadow-6277.herokuapp.com" ``` This ensures that any idle connections are closed by Phoenix before they reach Heroku's 55-second timeout window. ## Creating Environment Variables in Heroku The `DATABASE_URL` config var is automatically created by Heroku when we add the [Heroku Postgres add-on](https://elements.heroku.com/addons/heroku-postgresql). We can create the database via the Heroku toolbelt: ```console $ heroku addons:create heroku-postgresql:mini ``` Now we set the `POOL_SIZE` config var: ```console $ heroku config:set POOL_SIZE=18 ``` This value should be just under the number of available connections, leaving a couple open for migrations and mix tasks. The mini database allows 20 connections, so we set this number to 18. If additional dynos will share the database, reduce the `POOL_SIZE` to give each dyno an equal share. When running a mix task later (after we have pushed the project to Heroku) you will also want to limit its pool size like so: ```console $ heroku run "POOL_SIZE=2 mix hello.task" ``` So that Ecto does not attempt to open more than the available connections. We still have to create the `SECRET_KEY_BASE` config based on a random string. First, use `mix phx.gen.secret` to get a new secret: ```console $ mix phx.gen.secret xvafzY4y01jYuzLm3ecJqo008dVnU3CN4f+MamNd1Zue4pXvfvUjbiXT8akaIF53 ``` Your random string will be different; don't use this example value. Now set it in Heroku: ```console $ heroku config:set SECRET_KEY_BASE="xvafzY4y01jYuzLm3ecJqo008dVnU3CN4f+MamNd1Zue4pXvfvUjbiXT8akaIF53" Setting config vars and restarting mysterious-meadow-6277... done, v3 SECRET_KEY_BASE: xvafzY4y01jYuzLm3ecJqo008dVnU3CN4f+MamNd1Zue4pXvfvUjbiXT8akaIF53 ``` ## Deploy Time! Our project is now ready to be deployed on Heroku. Let's commit all our changes: ```console $ git add elixir_buildpack.config $ git commit -a -m "Use production config from Heroku ENV variables and decrease socket timeout" ``` And deploy: ```console $ git push heroku main Counting objects: 55, done. Delta compression using up to 8 threads. Compressing objects: 100% (49/49), done. Writing objects: 100% (55/55), 48.48 KiB | 0 bytes/s, done. Total 55 (delta 1), reused 0 (delta 0) remote: Compressing source files... done. remote: Building source: remote: remote: -----> Multipack app detected remote: -----> Fetching custom git buildpack... done remote: -----> elixir app detected remote: -----> Checking Erlang and Elixir versions remote: WARNING: elixir_buildpack.config wasn't found in the app remote: Using default config from Elixir buildpack remote: Will use the following versions: remote: * Stack cedar-14 remote: * Erlang 17.5 remote: * Elixir 1.0.4 remote: Will export the following config vars: remote: * Config vars DATABASE_URL remote: * MIX_ENV=prod remote: -----> Stack changed, will rebuild remote: -----> Fetching Erlang 17.5 remote: -----> Installing Erlang 17.5 (changed) remote: remote: -----> Fetching Elixir v1.0.4 remote: -----> Installing Elixir v1.0.4 (changed) remote: -----> Installing Hex remote: 2015-07-07 00:04:00 URL:https://s3.amazonaws.com/s3.hex.pm/installs/1.0.0/hex.ez [262010/262010] -> "/app/.mix/archives/hex.ez" [1] remote: * creating /app/.mix/archives/hex.ez remote: -----> Installing rebar remote: * creating /app/.mix/rebar remote: -----> Fetching app dependencies with mix remote: Running dependency resolution remote: Dependency resolution completed successfully remote: [...] remote: -----> Compiling remote: [...] remote: Generated phoenix_heroku app remote: [...] remote: Consolidated protocols written to _build/prod/consolidated remote: -----> Creating .profile.d with env vars remote: -----> Fetching custom git buildpack... done remote: -----> Phoenix app detected remote: remote: -----> Loading configuration and environment remote: Loading config... remote: [...] remote: Will export the following config vars: remote: * Config vars DATABASE_URL remote: * MIX_ENV=prod remote: remote: -----> Compressing... done, 82.1MB remote: -----> Launching... done, v5 remote: https://mysterious-meadow-6277.herokuapp.com/ deployed to Heroku remote: remote: Verifying deploy... done. To https://git.heroku.com/mysterious-meadow-6277.git * [new branch] master -> master ``` Typing `heroku open` in the terminal should launch a browser with the Phoenix welcome page opened. In the event that you are using Ecto to access a database, you will also need to run migrations after the first deploy: ```console $ heroku run "POOL_SIZE=2 mix ecto.migrate" ``` And that's it! ## Deploying to Heroku using the container stack ### Create Heroku application Set the stack of your app to `container`, this allows us to use `Dockerfile` to define our app setup. ```console $ heroku create Creating app... done, ⬢ mysterious-meadow-6277 $ heroku stack:set container ``` Add a new `heroku.yml` file to your root folder. In this file you can define addons used by your app, how to build the image and what configs are passed to the image. You can learn more about Heroku's `heroku.yml` options [here](https://devcenter.heroku.com/articles/build-docker-images-heroku-yml). Here is a sample: ```yaml setup: addons: - plan: heroku-postgresql as: DATABASE build: docker: web: Dockerfile config: MIX_ENV: prod SECRET_KEY_BASE: $SECRET_KEY_BASE DATABASE_URL: $DATABASE_URL ``` ### Set up releases and Dockerfile Now we need to define a `Dockerfile` at the root folder of your project that contains your application. We recommend to use releases when doing so, as the release will allow us to build a container with only the parts of Erlang and Elixir we actually use. Follow the [releases docs](releases.html). At the end of the guide, there is a sample Dockerfile file you can use. Once you have the image definition set up, you can push your app to heroku and you can see it starts building the image and deploy it. ## Useful Heroku Commands We can look at the logs of our application by running the following command in our project directory: ```console $ heroku logs # use --tail if you want to tail them ``` We can also start an IEx session attached to our terminal for experimenting in our app's environment: ```console $ heroku run "POOL_SIZE=2 iex -S mix" ``` In fact, we can run anything using the `heroku run` command, like the Ecto migration task from above: ```console $ heroku run "POOL_SIZE=2 mix ecto.migrate" ``` ## Connecting to your dyno Heroku gives you the ability to connect to your dyno with an IEx shell which allows running Elixir code such as database queries. - Modify the `web` process in your Procfile to run a named node: ```text web: elixir --sname server -S mix phx.server ``` - Redeploy to Heroku - Connect to the dyno with `heroku ps:exec` (if you have several applications on the same repository you will need to specify the app name or the remote name with `--app APP_NAME` or `--remote REMOTE_NAME`) - Launch an iex session with `iex --sname console --remsh server` You have an iex session into your dyno! ## Troubleshooting ### Compilation Error Occasionally, an application will compile locally, but not on Heroku. The compilation error on Heroku will look something like this: ```console remote: == Compilation error on file lib/postgrex/connection.ex == remote: could not compile dependency :postgrex, "mix compile" failed. You can recompile this dependency with "mix deps.compile postgrex", update it with "mix deps.update postgrex" or clean it with "mix deps.clean postgrex" remote: ** (CompileError) lib/postgrex/connection.ex:207: Postgrex.Connection.__struct__/0 is undefined, cannot expand struct Postgrex.Connection remote: (elixir) src/elixir_map.erl:58: :elixir_map.translate_struct/4 remote: (stdlib) lists.erl:1353: :lists.mapfoldl/3 remote: (stdlib) lists.erl:1354: :lists.mapfoldl/3 remote: remote: remote: ! Push rejected, failed to compile elixir app remote: remote: Verifying deploy... remote: remote: ! Push rejected to mysterious-meadow-6277. remote: To https://git.heroku.com/mysterious-meadow-6277.git ``` This has to do with stale dependencies which are not getting recompiled properly. It's possible to force Heroku to recompile all dependencies on each deploy, which should fix this problem. The way to do it is to add a new file called `elixir_buildpack.config` at the root of the application. The file should contain this line: ```text always_rebuild=true ``` Commit this file to the repository and try to push again to Heroku. ### Connection Timeout Error If you are constantly getting connection timeouts while running `heroku run` this could mean that your internet provider has blocked port number 5000: ```console heroku run "POOL_SIZE=2 mix myapp.task" Running POOL_SIZE=2 mix myapp.task on mysterious-meadow-6277... ! ETIMEDOUT: connect ETIMEDOUT 50.19.103.36:5000 ``` You can overcome this by adding `detached` option to run command: ```console heroku run:detached "POOL_SIZE=2 mix ecto.migrate" Running POOL_SIZE=2 mix ecto.migrate on mysterious-meadow-6277... done, run.8089 (Free) ``` ================================================ FILE: guides/deployment/releases.md ================================================ # Deploying with Releases Our main goal for this guide is to package your Phoenix application into a self-contained directory that includes the Erlang VM, Elixir, all of your code and dependencies. This package can then be dropped into a production machine. ## What we'll need The only thing we'll need for this guide is a working Phoenix application. For those of us who need a simple application to deploy, please follow the [Up and Running guide](up_and_running.html). ## Releases, assemble! If you are not familiar with Elixir releases yet, we recommend you to read [Elixir's excellent docs](https://hexdocs.pm/mix/Mix.Tasks.Release.html) before continuing. Once that is done, you can assemble a release by going through all of the steps in our general [deployment guide](deployment.html) with `mix release` at the end. Let's recap. First set the environment variables: ```console $ mix phx.gen.secret REALLY_LONG_SECRET $ export SECRET_KEY_BASE=REALLY_LONG_SECRET $ export DATABASE_URL=ecto://USER:PASS@HOST/database ``` Then load dependencies to compile code and assets: ```console # Initial setup $ mix deps.get --only prod $ MIX_ENV=prod mix compile # Compile assets $ MIX_ENV=prod mix assets.deploy ``` And now run `mix phx.gen.release`: ```console $ mix phx.gen.release ==> my_app * creating rel/overlays/bin/server * creating rel/overlays/bin/server.bat * creating rel/overlays/bin/migrate * creating rel/overlays/bin/migrate.bat * creating lib/my_app/release.ex Your application is ready to be deployed in a release! # To start your system _build/dev/rel/my_app/bin/my_app start # To start your system with the Phoenix server running _build/dev/rel/my_app/bin/server # To run migrations _build/dev/rel/my_app/bin/migrate Once the release is running: # To connect to it remotely _build/dev/rel/my_app/bin/my_app remote # To stop it gracefully (you may also send SIGINT/SIGTERM) _build/dev/rel/my_app/bin/my_app stop To list all commands: _build/dev/rel/my_app/bin/my_app ``` The `phx.gen.release` task generated a few files for us to assist in releases. First, it created `server` and `migrate` *overlay* scripts for conveniently running the phoenix server inside a release or invoking migrations from a release. The files in the `rel/overlays` directory are copied into every release environment. Next, it generated a `release.ex` file which is used to invoke Ecto migrations without a dependency on `mix` itself. *Note*: If you are a Docker user, you can pass the `--docker` flag to `mix phx.gen.release` to generate a Dockerfile ready for deployment. Next, we can invoke `mix release` to build the release: ```console $ MIX_ENV=prod mix release Generated my_app app * assembling my_app-0.1.0 on MIX_ENV=prod * using config/runtime.exs to configure the release at runtime Release created at _build/prod/rel/my_app! # To start your system _build/prod/rel/my_app/bin/my_app start ... ``` You can start the release by calling `_build/prod/rel/my_app/bin/my_app start`, or boot your webserver by calling `_build/prod/rel/my_app/bin/server`, where you have to replace `my_app` by your current application name. Now you can get all of the files under the `_build/prod/rel/my_app` directory, package it, and run it in any production machine with the same OS and architecture as the one that assembled the release. For more details, check the [docs for `mix release`](https://hexdocs.pm/mix/Mix.Tasks.Release.html). ## Ecto migrations A common need in production systems is to execute custom commands required to set up the production environment. One of such commands is precisely migrating the database. Since we don't have `Mix`, a *build* tool, inside releases, which are production artifacts, we need to bring said commands directly into the release. The `phx.gen.release` command created the following `release.ex` file in your project `lib/my_app/release.ex`, with the following content: ```elixir defmodule MyApp.Release do @app :my_app def migrate do load_app() for repo <- repos() do {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true)) end end def rollback(repo, version) do load_app() {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version)) end defp repos do Application.fetch_env!(@app, :ecto_repos) end defp load_app do Application.ensure_all_started(:ssl) Application.ensure_loaded(@app) end end ``` Where you replace the first two lines by your application names. Now you can assemble a new release with `MIX_ENV=prod mix release` and you can invoke any code, including the functions in the module above, by calling the `eval` command: ```console $ _build/prod/rel/my_app/bin/my_app eval "MyApp.Release.migrate" ``` And that's it! If you peek inside the `migrate` script, you'll see it wraps exactly this invocation. Depending on where you are deploying your application, you can invoke the `migrate` command separately, or you may want to change the `server` script to migrate your database before starting your app. ## Custom commands You can use the same approach used for migrations to create any custom command to run in production. The idea is that each command invokes `load_app`, which calls `Application.ensure_loaded/1` to load the current application without starting it. However, some commands may need to start the whole application. In such cases, `Application.ensure_all_started/1` must be used instead of `Application.load/1`. Keep in mind starting the application will start all processes in its supervision tree, including the Phoenix endpoint. This can be circumvented by changing your supervision tree to not start certain children under certain conditions. For example, in the release commands file you could do: ```elixir defp start_app do load_app() Application.put_env(@app, :minimal, true) Application.ensure_all_started(@app) end ``` And then in your application you check `Application.get_env(@app, :minimal)` and start only part of the children when it is set. ## Containers Elixir releases work well with container technologies such as Docker. The idea is that you assemble the release inside the Docker container and then build an image based on the release artifacts. If you call `mix phx.gen.release --docker`, you'll see a new file with content similar to: ```Dockerfile # Find eligible builder and runner images on Docker Hub. We use Ubuntu/Debian # instead of Alpine to avoid DNS resolution issues in production. # # https://hub.docker.com/r/hexpm/elixir/tags?page=1&name=ubuntu # https://hub.docker.com/_/ubuntu?tab=tags # # This file is based on these images: # # - https://hub.docker.com/r/hexpm/elixir/tags - for the build image # - https://hub.docker.com/_/debian?tab=tags&page=1&name=bullseye-20230612-slim - for the release image # - https://pkgs.org/ - resource for finding needed packages # - Ex: hexpm/elixir:1.18.4-erlang-27.3.4.3-debian-trixie-20250908-slim # ARG ELIXIR_VERSION=1.18.4 ARG OTP_VERSION=27.3.4.3 ARG DEBIAN_VERSION=trixie-20250908-slim ARG BUILDER_IMAGE="hexpm/elixir:${ELIXIR_VERSION}-erlang-${OTP_VERSION}-debian-${DEBIAN_VERSION}" ARG RUNNER_IMAGE="debian:${DEBIAN_VERSION}" FROM ${BUILDER_IMAGE} AS builder # install build dependencies RUN apt-get update \ && apt-get install -y --no-install-recommends build-essential git \ && rm -rf /var/lib/apt/lists/* # prepare build dir WORKDIR /app # install hex + rebar RUN mix local.hex --force \ && mix local.rebar --force # set build ENV ENV MIX_ENV="prod" # install mix dependencies COPY mix.exs mix.lock ./ RUN mix deps.get --only $MIX_ENV RUN mkdir config # copy compile-time config files before we compile dependencies # to ensure any relevant config change will trigger the dependencies # to be re-compiled. COPY config/config.exs config/${MIX_ENV}.exs config/ RUN mix deps.compile RUN mix assets.setup COPY priv priv COPY lib lib # Compile the release RUN mix compile COPY assets assets # compile assets RUN mix assets.deploy # Changes to config/runtime.exs don't require recompiling the code COPY config/runtime.exs config/ COPY rel rel RUN mix release # start a new build stage so that the final image will only contain # the compiled release and other runtime necessities FROM ${RUNNER_IMAGE} AS final RUN apt-get update \ && apt-get install -y --no-install-recommends libstdc++6 openssl libncurses6 locales ca-certificates \ && rm -rf /var/lib/apt/lists/* # Set the locale RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen \ && locale-gen ENV LANG=en_US.UTF-8 ENV LANGUAGE=en_US:en ENV LC_ALL=en_US.UTF-8 WORKDIR "/app" RUN chown nobody /app # set runner ENV ENV MIX_ENV="prod" # Only copy the final release from the build stage COPY --from=builder --chown=nobody:root /app/_build/${MIX_ENV}/rel/my_app ./ USER nobody # If using an environment that doesn't automatically reap zombie processes, it is # advised to add an init process such as tini via `apt-get install` # above and adding an entrypoint. See https://github.com/krallin/tini for details # ENTRYPOINT ["/tini", "--"] CMD ["/app/bin/server"] ``` Where `my_app` is the name of your app. At the end, you will have an application in `/app` ready to run as `/app/bin/server`. A few points about configuring a containerized application: - The more configuration you can provide at runtime (using `config/runtime.exs`), the more reusable your images will be across environments. In particular, secrets like database credentials and API keys should not be compiled into the image, but rather should be provided when creating containers based on that image. This is why the `Endpoint`'s `:secret_key_base` is configured in `config/runtime.exs` by default. - If possible, any environment variables that are needed at runtime should be read in `config/runtime.exs`, not scattered throughout your code. Having them all visible in one place will make it easier to ensure the containers get what they need, especially if the person doing the infrastructure work does not work on the Elixir code. Libraries in particular should never directly read environment variables; all their configuration should be handed to them by the top-level application, preferably [without using the application environment](https://hexdocs.pm/elixir/design-anti-patterns.html#using-application-configuration-for-libraries). ## Clustering Elixir and the Erlang VM have the incredible ability to be clustered together and pass messages seamlessly between nodes. To enable clustering, we need two distinct features: * Node connection: different instances of the same service should communicate with each other. This is a feature of the Erlang VM. * Service discovery: for a given service, you must be able to find the IP address of all instances. Phoenix ships with `dns_cluster` to provide out-of-the-box DNS-based service discovery but alternative methods may be used. ### DNS Discovery Your clustering configuration is typically added to `rel/env.sh.eex`. This is a file that is executed before you release starts, and it is a perfect place to configure your application runtime based on your deployment environment. Here is a general skeleton: ```sh # Uncomment if IPv6 is required # export ECTO_IPV6="true" # export ERL_AFLAGS="-proto_dist inet6_tcp" # Erlang uses a port mapper daemon on each node, # it by default runs on port 4369 export ERL_EPMD_PORT=4369 # Use the ports 4370-4372 for nodes to communicate. export ERL_AFLAGS="-kernel inet_dist_listen_min 4370 inet_dist_listen_max 4372" export RELEASE_DISTRIBUTION="name" export RELEASE_NODE="app-${PLATFORM_DEPLOYMENT_SHA}@${PLATFORM_DEPLOYMENT_IP}" export DNS_CLUSTER_QUERY="your-app.internal" ``` The script above is doing a couple things: * It configures your app to use ports 4369, 4370, 4371, and 4372 for communication. You may need to explicitly expose those as internal TCP ports in your deployment platform (in addition to the HTTP port of your choice) * It then configures your app to use fully qualified names. The name of each app will include the current deployment sha as `PLATFORM_DEPLOYMENT_SHA` (the name of the exact environment variable is platform dependent), so each deployment establishes its own cluster, and the current IP as `PLATFORM_DEPLOYMENT_IP` (also platform specific). If the IP is not available, you may be able to compute it as `NODE_IP=hostname | tr -d ' '` * Then finally you define a DNS query which will be used to find the IPs of the other instances Some platforms, such as [Fly.io](https://fly.io/docs/networking/private-networking/), [Railway](https://docs.railway.com/guides/private-networking), and [Render](https://render.com/docs/private-network#direct-ip-communication-advanced), provide private networks with DNS querying out of the box. You only need to adapt the `DNS_CLUSTER_QUERY` variable accordingly. Other platforms, such as [Digital Ocean App Platform](https://www.digitalocean.com/products/app-platform) and [Northflank](https://northflank.com/features/platform), allow nodes to directly connect to each other, but they do not provide DNS service discovery. In this next section, we explore different service discovery mechanisms. ### Alternative discovery mechanisms While not all platforms support DNS queries for service discovery, there are many alternative strategies for connecting your nodes together. Please checkout the following libraries: * [libcluster](https://github.com/bitwalker/libcluster) - provides strategies for connecting your nodes using gossip protocols, kubernetes, ec2, and others * [libcluster_postgres](https://github.com/supabase/libcluster_postgres/) - a plugin for `libcluster` which uses PostgreSQL for node discovery. Given most applications already use a database, and likely PostgreSQL, this is a suitable option which does not require additional setup When using the libraries above, you can likely remove `dns_query` from your application dependencies. ### `epmd`-less deployment In the snippet above, we used ports 4369, 4370, 4371, and 4372. However, the Erlang VM allows running the distribution over a fixed port, also known as `epmd`-less deployments. To enable such, do this. Remove the lines: ```sh export ERL_EPMD_PORT=4369 export ERL_AFLAGS="-kernel inet_dist_listen_min 4370 inet_dist_listen_max 4372" ``` Add a file rel/vm.args.eex with the following: ``` -start_epmd false -erl_epmd_port 6789 ``` Add a file rel/remote.vm.args.eex with the following: ``` -start_epmd false -erl_epmd_port 6789 -dist_listen false ``` And now only port 6789 (in addition to the HTTP one) needs to be exposed internally between instances. ================================================ FILE: guides/directory_structure.md ================================================ # Directory structure > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). When we use `mix phx.new` to generate a new Phoenix application, it builds a top-level directory structure like this: ```console ├── _build ├── assets ├── config ├── deps ├── lib │   ├── hello │   ├── hello.ex │   ├── hello_web │   └── hello_web.ex ├── priv └── test ``` We will go over those directories one by one: * `_build` - a directory that holds all compilation artifacts, created by the `mix` command line tool (shipped as part of Elixir). As we have seen in "[Up and Running](up_and_running.html)", `mix` is the main interface to your application. We use Mix to compile our code, create databases, run our server, and more. This directory must not be checked into version control and it can be removed at any time. Removing it will force Mix to rebuild your application from scratch. * `assets` - a directory that keeps source code for your front-end assets, typically JavaScript and CSS. These sources are automatically bundled by the `esbuild` tool. Static files like images and fonts go in `priv/static`. * `config` - a directory that holds your project configuration. The `config/config.exs` file is the entry point for your configuration. At the end of the `config/config.exs`, it imports environment specific configuration, which can be found in `config/dev.exs`, `config/test.exs`, and `config/prod.exs`. Finally, `config/runtime.exs` is executed and it is the best place to read secrets and other dynamic configuration. * `deps` - a directory with all of our Mix dependencies. You can find all dependencies listed in the `mix.exs` file, inside the `defp deps do` function definition. This directory must not be checked into version control and it can be removed at any time. Removing it will force Mix to download all deps from scratch. * `lib` - a directory that holds your application source code. This directory is broken into two subdirectories, `lib/hello` and `lib/hello_web`. The `lib/hello` directory is responsible for hosting all of your business logic and business domain. It typically interacts directly with the database - it is the "Model" in Model-View-Controller (MVC) architecture. `lib/hello_web` is responsible for exposing your business domain to the world, in this case, through a web application. It holds both the View and Controller from MVC. We will discuss the contents of these directories in more detail in the next sections. * `priv` - a directory that keeps all resources that are necessary in production but are not directly part of your source code. You typically keep database scripts, translation files, images, and more in here. Generated assets, created from files in the `assets` directory, are placed in `priv/static/assets` by default. * `test` - a directory with all of our application tests. It often mirrors the same structure found in `lib`. ## The lib/hello directory The `lib/hello` directory hosts all of your business domain. Since our project does not have any business logic yet, the directory is mostly empty. You will only find three files: ```console lib/hello ├── application.ex ├── mailer.ex └── repo.ex ``` The `lib/hello/application.ex` file defines an Elixir application named `Hello.Application`. That's because at the end of the day Phoenix applications are simply Elixir applications. The `Hello.Application` module defines which services are part of our application: ```elixir children = [ HelloWeb.Telemetry, Hello.Repo, {Phoenix.PubSub, name: Hello.PubSub}, HelloWeb.Endpoint ] ``` If it is your first time with Phoenix, you don't need to worry about the details right now. For now, suffice it to say our application starts a database repository, a PubSub system for sharing messages across processes and nodes, and the application endpoint, which effectively serves HTTP requests. These services are started in the order they are defined and, whenever shutting down your application, they are stopped in the reverse order. You can learn more about applications in [Elixir's official docs for Application](https://hexdocs.pm/elixir/Application.html). The `lib/hello/mailer.ex` file holds the `Hello.Mailer` module, which defines the main interface to deliver e-mails: ```elixir defmodule Hello.Mailer do use Swoosh.Mailer, otp_app: :hello end ``` In the same `lib/hello` directory, we will find a `lib/hello/repo.ex`. It defines a `Hello.Repo` module which is our main interface to the database. If you are using Postgres (the default database), you will see something like this: ```elixir defmodule Hello.Repo do use Ecto.Repo, otp_app: :hello, adapter: Ecto.Adapters.Postgres end ``` And that's it for now. As you work on your project, we will add files and modules to this directory. ## The lib/hello_web directory The `lib/hello_web` directory holds the web-related parts of our application. It looks like this when expanded: ```console lib/hello_web ├── controllers │   ├── page_controller.ex │   ├── page_html.ex │   ├── error_html.ex │   ├── error_json.ex │   └── page_html │   └── home.html.heex ├── components │   ├── core_components.ex │   ├── layouts.ex │   └── layouts │   └── root.html.heex ├── endpoint.ex ├── gettext.ex ├── router.ex └── telemetry.ex ``` All of the files which are currently in the `controllers` and `components` directories are there to create the "Welcome to Phoenix!" page we saw in the "[Up and running](up_and_running.html)" guide. By looking at `controller` and `components` directories, we can see Phoenix provides features for handling layouts, HTML, and error pages out of the box. Besides the directories mentioned, `lib/hello_web` has four files at its root. `lib/hello_web/endpoint.ex` is the entry-point for HTTP requests. Once the browser accesses [http://localhost:4000](http://localhost:4000), the endpoint starts processing the data, eventually leading to the router, which is defined in `lib/hello_web/router.ex`. The router defines the rules to dispatch requests to "controllers", which calls a view module to render HTML pages back to clients. We explore these layers in length in other guides, starting with the "[Request life-cycle](request_lifecycle.html)" guide coming next. Through _Telemetry_, Phoenix is able to collect metrics and send monitoring events of your application. The `lib/hello_web/telemetry.ex` file defines the supervisor responsible for managing the telemetry processes. You can find more information on this topic in the [Telemetry guide](telemetry.html). Finally, there is a `lib/hello_web/gettext.ex` file which provides internationalization through [Gettext](https://hexdocs.pm/gettext/Gettext.html). If you are not worried about internationalization, you can safely skip this file and its contents. ## The assets directory The `assets` directory contains source files related to front-end assets, such as JavaScript and CSS. Since Phoenix v1.6, we use [`esbuild`](https://github.com/evanw/esbuild/) to compile assets, which is managed by the [`esbuild`](https://github.com/phoenixframework/esbuild) Elixir package. The integration with `esbuild` is baked into your app. The relevant config can be found in your `config/config.exs` file. Your other static assets are placed in the `priv/static` folder, where `priv/static/assets` is kept for generated assets. Everything in `priv/static` is served by the `Plug.Static` plug configured in `lib/hello_web/endpoint.ex`. When running in dev mode (`MIX_ENV=dev`), Phoenix watches for any changes you make in the `assets` directory, and then takes care of updating your front end application in your browser as you work. Note that when you first create your Phoenix app using `mix phx.new` it is possible to specify options that will affect the presence and layout of the `assets` directory. In fact, Phoenix apps can bring their own front end tools or not have a front-end at all (handy if you're writing an API for example). For more information you can run `mix help phx.new`. If the default esbuild integration does not cover your needs, for example because you want to use another build tool, you can switch to a [custom assets build](asset_management.html#custom_builds). As for CSS, Phoenix ships with the [Tailwind CSS Framework](https://tailwindcss.com/), providing a base setup for projects. You may move to any CSS framework of your choice. Additional references can be found in the [asset management](asset_management.md#css) guide. ================================================ FILE: guides/ecto.md ================================================ # Ecto > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). Most web applications today need some form of data validation and persistence. In the Elixir ecosystem, we have `Ecto` to enable this. Before we jump into building database-backed web features, we're going to focus on the finer details of Ecto to give a solid base to build our web features on top of. Let's get started! Phoenix uses Ecto to provide builtin support to the following databases: * PostgreSQL (via [`postgrex`](https://github.com/elixir-ecto/postgrex)) * MySQL (via [`myxql`](https://github.com/elixir-ecto/myxql)) * MSSQL (via [`tds`](https://github.com/livehelpnow/tds)) * ETS (via [`etso`](https://github.com/evadne/etso)) * SQLite3 (via [`ecto_sqlite3`](https://github.com/elixir-sqlite/ecto_sqlite3)) Newly generated Phoenix projects include Ecto with the PostgreSQL adapter by default. You can pass the `--database` option to change or `--no-ecto` flag to exclude this. Ecto also provides support for other databases and it has many learning resources available. Please check out [Ecto's README](https://github.com/elixir-ecto/ecto) for general information. This guide assumes that we have generated our new application with Ecto integration and that we will be using PostgreSQL. The introductory guides cover how to get your first application up and running. For using other databases, see the [Swapping Databases](swapping_databases.html) how-to guide. ## Using `phx.gen.schema` Once we have Ecto and PostgreSQL installed and configured, the easiest way to use Ecto is to generate an Ecto *schema* through the `phx.gen.schema` task. Ecto schemas are a way for us to specify how Elixir data types map to and from external sources, such as database tables. Let's generate a `User` schema with `name`, `email`, `bio`, and `number_of_pets` fields. ```console $ mix phx.gen.schema User users name:string email:string \ bio:string number_of_pets:integer * creating ./lib/hello/user.ex * creating priv/repo/migrations/20170523151118_create_users.exs Remember to update your repository by running migrations: $ mix ecto.migrate ``` A couple of files were generated with this task. First, we have a `user.ex` file, containing our Ecto schema with our schema definition of the fields we passed to the task. Next, a migration file was generated inside `priv/repo/migrations/` which will create our database table that our schema maps to. With our files in place, let's follow the instructions and run our migration: ```console $ mix ecto.migrate Compiling 1 file (.ex) Generated hello app [info] == Running Hello.Repo.Migrations.CreateUsers.change/0 forward [info] create table users [info] == Migrated in 0.0s ``` Mix assumes that we are in the development environment unless we tell it otherwise with `MIX_ENV=prod mix ecto.migrate`. If we log in to our database server, and connect to our `hello_dev` database, we should see our `users` table. Ecto assumes that we want an integer column called `id` as our primary key, so we should see a sequence generated for that as well. ```console $ psql -U postgres Type "help" for help. postgres=# \connect hello_dev You are now connected to database "hello_dev" as user "postgres". hello_dev=# \d List of relations Schema | Name | Type | Owner --------+-------------------+----------+---------- public | schema_migrations | table | postgres public | users | table | postgres public | users_id_seq | sequence | postgres (3 rows) hello_dev=# \q ``` If we take a look at the migration generated by `phx.gen.schema` in `priv/repo/migrations/`, we'll see that it will add the columns we specified. It will also add timestamp columns for `inserted_at` and `updated_at` which come from the [`timestamps/1`] function. ```elixir defmodule Hello.Repo.Migrations.CreateUsers do use Ecto.Migration def change do create table(:users) do add :name, :string add :email, :string add :bio, :string add :number_of_pets, :integer timestamps(type: :utc_datetime) end end end ``` And here's what that translates to in the actual `users` table. ```console $ psql hello_dev=# \d users Table "public.users" Column | Type | Modifiers ---------------+--------------------------------+---------------------------------------------------- id | bigint | not null default nextval('users_id_seq'::regclass) name | character varying(255) | email | character varying(255) | bio | character varying(255) | number_of_pets | integer | inserted_at | timestamp(0) without time zone | not null updated_at | timestamp(0) without time zone | not null Indexes: "users_pkey" PRIMARY KEY, btree (id) ``` Notice that we do get an `id` column as our primary key by default, even though it isn't listed as a field in our migration. ## Repo configuration Our `Hello.Repo` module is the foundation we need to work with databases in a Phoenix application. Phoenix generated it for us in `lib/hello/repo.ex`, and this is what it looks like. ```elixir defmodule Hello.Repo do use Ecto.Repo, otp_app: :hello, adapter: Ecto.Adapters.Postgres end ``` It begins by defining the repository module. Then it configures our `otp_app` name, and the `adapter` – `Postgres`, in our case. Our repo has three main tasks - to bring in all the common query functions from [`Ecto.Repo`], to set the `otp_app` name equal to our application name, and to configure our database adapter. We'll talk more about how to use `Hello.Repo` in a bit. When `phx.new` generated our application, it included some basic repository configuration as well. Let's look at `config/dev.exs`. ```elixir ... # Configure your database config :hello, Hello.Repo, username: "postgres", password: "postgres", hostname: "localhost", database: "hello_dev", show_sensitive_data_on_connection_error: true, pool_size: 10 ... ``` We also have similar configuration in `config/test.exs` and `config/runtime.exs` which can also be changed to match your actual credentials. ## The schema Ecto schemas are responsible for mapping Elixir values to external data sources, as well as mapping external data back into Elixir data structures. We can also define relationships to other schemas in our applications. For example, our `User` schema might have many posts, and each post would belong to a user. Ecto also handles data validation and type casting with changesets, which we'll discuss in a moment. Here's the `User` schema that Phoenix generated for us. ```elixir defmodule Hello.User do use Ecto.Schema import Ecto.Changeset schema "users" do field :bio, :string field :email, :string field :name, :string field :number_of_pets, :integer timestamps(type: :utc_datetime) end @doc false def changeset(user, attrs) do user |> cast(attrs, [:name, :email, :bio, :number_of_pets]) |> validate_required([:name, :email, :bio, :number_of_pets]) end end ``` Ecto schemas at their core are simply Elixir structs. Our `schema` block is what tells Ecto how to cast our `%User{}` struct fields to and from the external `users` table. Often, the ability to simply cast data to and from the database isn't enough and extra data validation is required. This is where Ecto changesets come in. Let's dive in! ## Changesets and validations Changesets define a pipeline of transformations our data needs to undergo before it will be ready for our application to use. These transformations might include type-casting, user input validation, and filtering out any extraneous parameters. Often we'll use changesets to validate user input before writing it to the database. Ecto repositories are also changeset-aware, which allows them not only to refuse invalid data, but also perform the minimal database updates possible by inspecting the changeset to know which fields have changed. Let's take a closer look at our default changeset function. ```elixir def changeset(user, attrs) do user |> cast(attrs, [:name, :email, :bio, :number_of_pets]) |> validate_required([:name, :email, :bio, :number_of_pets]) end ``` Right now, we have two transformations in our pipeline. In the first call, we invoke `Ecto.Changeset.cast/3`, passing in our external parameters and marking which fields are required for validation. [`cast/3`] first takes a struct, then the parameters (the proposed updates), and then the final field is the list of columns to be updated. [`cast/3`] also will only take fields that exist in the schema. Next, `Ecto.Changeset.validate_required/3` checks that this list of fields is present in the changeset that [`cast/3`] returns. By default with the generator, all fields are required. We can verify this functionality in `IEx`. Let's fire up our application inside IEx by running `iex -S mix`. In order to minimize typing and make this easier to read, let's alias our `Hello.User` struct. ```console $ iex -S mix iex> alias Hello.User Hello.User ``` Next, let's build a changeset from our schema with an empty `User` struct, and an empty map of parameters. ```elixir iex> changeset = User.changeset(%User{}, %{}) #Ecto.Changeset< action: nil, changes: %{}, errors: [ name: {"can't be blank", [validation: :required]}, email: {"can't be blank", [validation: :required]}, bio: {"can't be blank", [validation: :required]}, number_of_pets: {"can't be blank", [validation: :required]} ], data: #Hello.User<>, valid?: false > ``` Once we have a changeset, we can check if it is valid. ```elixir iex> changeset.valid? false ``` Since this one is not valid, we can ask it what the errors are. ```elixir iex> changeset.errors [ name: {"can't be blank", [validation: :required]}, email: {"can't be blank", [validation: :required]}, bio: {"can't be blank", [validation: :required]}, number_of_pets: {"can't be blank", [validation: :required]} ] ``` Now, let's make `number_of_pets` optional. In order to do this, we simply remove it from the list in the `changeset/2` function, in `Hello.User`. ```elixir |> validate_required([:name, :email, :bio]) ``` Now casting the changeset should tell us that only `name`, `email`, and `bio` can't be blank. We can test that by running `recompile()` inside IEx and then rebuilding our changeset. ```elixir iex> recompile() Compiling 1 file (.ex) :ok iex> changeset = User.changeset(%User{}, %{}) #Ecto.Changeset< action: nil, changes: %{}, errors: [ name: {"can't be blank", [validation: :required]}, email: {"can't be blank", [validation: :required]}, bio: {"can't be blank", [validation: :required]} ], data: #Hello.User<>, valid?: false > iex> changeset.errors [ name: {"can't be blank", [validation: :required]}, email: {"can't be blank", [validation: :required]}, bio: {"can't be blank", [validation: :required]} ] ``` What happens if we pass a key-value pair that is neither defined in the schema nor required? Inside our existing IEx shell, let's create a `params` map with valid values plus an extra `random_key: "random value"`. ```elixir iex> params = %{name: "Joe Example", email: "joe@example.com", bio: "An example to all", number_of_pets: 5, random_key: "random value"} %{ bio: "An example to all", email: "joe@example.com", name: "Joe Example", number_of_pets: 5, random_key: "random value" } ``` Next, let's use our new `params` map to create another changeset. ```elixir iex> changeset = User.changeset(%User{}, params) #Ecto.Changeset< action: nil, changes: %{ bio: "An example to all", email: "joe@example.com", name: "Joe Example", number_of_pets: 5 }, errors: [], data: #Hello.User<>, valid?: true > ``` Our new changeset is valid. ```elixir iex> changeset.valid? true ``` We can also check the changeset's changes - the map we get after all of the transformations are complete. ```elixir iex(9)> changeset.changes %{bio: "An example to all", email: "joe@example.com", name: "Joe Example", number_of_pets: 5} ``` Notice that our `random_key` key and `"random_value"` value have been removed from the final changeset. Changesets allow us to cast external data, such as user input on a web form or data from a CSV file into valid data into our system. Invalid parameters will be stripped and bad data that is unable to be cast according to our schema will be highlighted in the changeset errors. We can validate more than just whether a field is required or not. Let's take a look at some finer-grained validations. What if we had a requirement that all biographies in our system must be at least two characters long? We can do this easily by adding another transformation to the pipeline in our changeset which validates the length of the `bio` field. ```elixir def changeset(user, attrs) do user |> cast(attrs, [:name, :email, :bio, :number_of_pets]) |> validate_required([:name, :email, :bio, :number_of_pets]) |> validate_length(:bio, min: 2) end ``` Now, if we try to cast data containing a value of `"A"` for our user's `bio`, we should see the failed validation in the changeset's errors. ```elixir iex> recompile() iex> changeset = User.changeset(%User{}, %{bio: "A"}) iex> changeset.errors[:bio] {"should be at least %{count} character(s)", [count: 2, validation: :length, kind: :min, type: :string]} ``` If we also have a requirement for the maximum length that a bio can have, we can simply add another validation. ```elixir def changeset(user, attrs) do user |> cast(attrs, [:name, :email, :bio, :number_of_pets]) |> validate_required([:name, :email, :bio, :number_of_pets]) |> validate_length(:bio, min: 2) |> validate_length(:bio, max: 140) end ``` Let's say we want to perform at least some rudimentary format validation on the `email` field. All we want to check for is the presence of the `@`. The `Ecto.Changeset.validate_format/3` function is just what we need. ```elixir def changeset(user, attrs) do user |> cast(attrs, [:name, :email, :bio, :number_of_pets]) |> validate_required([:name, :email, :bio, :number_of_pets]) |> validate_length(:bio, min: 2) |> validate_length(:bio, max: 140) |> validate_format(:email, ~r/@/) end ``` If we try to cast a user with an email of `"example.com"`, we should see an error message like the following: ```elixir iex> recompile() iex> changeset = User.changeset(%User{}, %{email: "example.com"}) iex> changeset.errors[:email] {"has invalid format", [validation: :format]} ``` There are many more validations and transformations we can perform in a changeset. Please see the [Ecto Changeset documentation](https://hexdocs.pm/ecto/Ecto.Changeset.html) for more information. ## Data persistence We've explored migrations and schemas, but we haven't yet persisted any of our schemas or changesets. We briefly looked at our repository module in `lib/hello/repo.ex` earlier, and now it's time to put it to use. Ecto repositories are the interface into a storage system, be it a database like PostgreSQL or an external service like a RESTful API. The `Repo` module's purpose is to take care of the finer details of persistence and data querying for us. As the caller, we only care about fetching and persisting data. The `Repo` module takes care of the underlying database adapter communication, connection pooling, and error translation for database constraint violations. Let's head back over to IEx with `iex -S mix`, and insert a couple of users into the database. ```elixir iex> alias Hello.{Repo, User} [Hello.Repo, Hello.User] iex> Repo.insert(%User{email: "user1@example.com"}) [debug] QUERY OK db=6.5ms queue=0.5ms idle=1358.3ms INSERT INTO "users" ("email","inserted_at","updated_at") VALUES ($1,$2,$3) RETURNING "id" ["user1@example.com", ~U[2021-02-25 01:58:55Z], ~U[2021-02-25 01:58:55Z]] {:ok, %Hello.User{ __meta__: #Ecto.Schema.Metadata<:loaded, "users">, bio: nil, email: "user1@example.com", id: 1, inserted_at: ~U[2021-02-25 01:58:55Z], name: nil, number_of_pets: nil, updated_at: ~U[2021-02-25 01:58:55Z] }} iex> Repo.insert(%User{email: "user2@example.com"}) [debug] QUERY OK db=1.3ms idle=1402.7ms INSERT INTO "users" ("email","inserted_at","updated_at") VALUES ($1,$2,$3) RETURNING "id" ["user2@example.com", ~U[2021-02-25 02:03:28Z], ~U[2021-02-25 02:03:28Z]] {:ok, %Hello.User{ __meta__: #Ecto.Schema.Metadata<:loaded, "users">, bio: nil, email: "user2@example.com", id: 2, inserted_at: ~U[2021-02-25 02:03:28Z], name: nil, number_of_pets: nil, updated_at: ~U[2021-02-25 02:03:28Z] }} ``` We started by aliasing our `User` and `Repo` modules for easy access. Next, we called [`Repo.insert/2`] with a User struct. Since we are in the `dev` environment, we can see the debug logs for the query our repository performed when inserting the underlying `%User{}` data. We received a two-element tuple back with `{:ok, %User{}}`, which lets us know the insertion was successful. We could also insert a user by passing a changeset to [`Repo.insert/2`]. If the changeset is valid, the repository will use an optimized database query to insert the record, and return a two-element tuple back, as above. If the changeset is not valid, we receive a two-element tuple consisting of `:error` plus the invalid changeset. With a couple of users inserted, let's fetch them back out of the repo. ```elixir iex> Repo.all(User) [debug] QUERY OK source="users" db=5.8ms queue=1.4ms idle=1672.0ms SELECT u0."id", u0."bio", u0."email", u0."name", u0."number_of_pets", u0."inserted_at", u0."updated_at" FROM "users" AS u0 [] [ %Hello.User{ __meta__: #Ecto.Schema.Metadata<:loaded, "users">, bio: nil, email: "user1@example.com", id: 1, inserted_at: ~U[2021-02-25 01:58:55Z], name: nil, number_of_pets: nil, updated_at: ~U[2021-02-25 01:58:55Z] }, %Hello.User{ __meta__: #Ecto.Schema.Metadata<:loaded, "users">, bio: nil, email: "user2@example.com", id: 2, inserted_at: ~U[2021-02-25 02:03:28Z], name: nil, number_of_pets: nil, updated_at: ~U[2021-02-25 02:03:28Z] } ] ``` That was easy! `Repo.all/1` takes a data source, our `User` schema in this case, and translates that to an underlying SQL query against our database. After it fetches the data, the Repo then uses our Ecto schema to map the database values back into Elixir data structures according to our `User` schema. We're not just limited to basic querying – Ecto includes a full-fledged query DSL for advanced SQL generation. In addition to a natural Elixir DSL, Ecto's query engine gives us multiple great features, such as SQL injection protection and compile-time optimization of queries. Let's try it out. ```elixir iex> import Ecto.Query Ecto.Query iex> Repo.all(from u in User, select: u.email) [debug] QUERY OK source="users" db=0.8ms queue=0.9ms idle=1634.0ms SELECT u0."email" FROM "users" AS u0 [] ["user1@example.com", "user2@example.com"] ``` First, we imported `Ecto.Query`, which imports the [`from/2`] macro of Ecto's Query DSL. Next, we built a query which selects all the email addresses in our users table. Let's try another example. ```elixir iex> Repo.one(from u in User, where: ilike(u.email, "%1%"), select: count(u.id)) [debug] QUERY OK source="users" db=1.6ms SELECT count(u0."id") FROM "users" AS u0 WHERE (u0."email" ILIKE '%1%') [] 1 ``` Now we're starting to get a taste of Ecto's rich querying capabilities. We used [`Repo.one/2`] to fetch the count of all users with an email address containing `1`, and received the expected count in return. This just scratches the surface of Ecto's query interface, and much more is supported such as sub-querying, interval queries, and advanced select statements. For example, let's build a query to fetch a map of all user id's to their email addresses. ```elixir iex> Repo.all(from u in User, select: %{u.id => u.email}) [debug] QUERY OK source="users" db=0.9ms SELECT u0."id", u0."email" FROM "users" AS u0 [] [ %{1 => "user1@example.com"}, %{2 => "user2@example.com"} ] ``` That little query packed a big punch. It both fetched all user emails from the database and efficiently built a map of the results in one go. You should browse the [Ecto.Query documentation](https://hexdocs.pm/ecto/Ecto.Query.html#content) to see the breadth of supported query features. In addition to inserts, we can also perform updates and deletes with [`Repo.update/2`] and [`Repo.delete/2`] to update or delete a single schema. Ecto also supports bulk persistence with the [`Repo.insert_all/3`], [`Repo.update_all/3`], and [`Repo.delete_all/2`] functions. There is quite a bit more that Ecto can do and we've only barely scratched the surface. With a solid Ecto foundation in place, we're now ready to continue building our app and integrate the web-facing application with our backend persistence. Along the way, we'll expand our Ecto knowledge and learn how to properly isolate our web interface from the underlying details of our system. Please take a look at the [Ecto documentation](https://hexdocs.pm/ecto/) for the rest of the story. In our [Data modelling guides](contexts.html), we'll find out how to wrap up our Ecto access and business logic behind modules that group related functionality. We'll see how Phoenix helps us design maintainable applications, and we'll find out about other neat Ecto features along the way. ## Mix tasks Ecto comes with a collection of Mix tasks to make it easier to manage your database and your application. Here is a quick look into the most important ones. ### `mix ecto.create` This task will create the database specified by our application repositories, but we can pass in another repo if we want. Here's what it looks like in action. ```console $ mix ecto.create The database for Hello.Repo has been created. ``` There are a few things that can go wrong with `ecto.create`. If our Postgres database doesn't have a "postgres" role (user), we'll get an error like this one. ```console $ mix ecto.create ** (Mix) The database for Hello.Repo couldn't be created, reason given: psql: FATAL: role "postgres" does not exist ``` We can fix this by creating the "postgres" role in the `psql` console with the permissions needed to log in and create a database. ```console =# CREATE ROLE postgres LOGIN CREATEDB; CREATE ROLE ``` If the "postgres" role does not have permission to log in to the application, we'll get this error. ```console $ mix ecto.create ** (Mix) The database for Hello.Repo couldn't be created, reason given: psql: FATAL: role "postgres" is not permitted to log in ``` To fix this, we need to change the permissions on our "postgres" user to allow login. ```console =# ALTER ROLE postgres LOGIN; ALTER ROLE ``` If the "postgres" role does not have permission to create a database, we'll get this error. ```console $ mix ecto.create ** (Mix) The database for Hello.Repo couldn't be created, reason given: ERROR: permission denied to create database ``` To fix this, we need to change the permissions on our "postgres" user in the `psql` console to allow database creation. ```console =# ALTER ROLE postgres CREATEDB; ALTER ROLE ``` If the "postgres" role is using a password different from the default "postgres", we'll get this error. ```console $ mix ecto.create ** (Mix) The database for Hello.Repo couldn't be created, reason given: psql: FATAL: password authentication failed for user "postgres" ``` To fix this, we can change the password in the environment specific configuration file. For the development environment the password used can be found at the bottom of the `config/dev.exs` file. Finally, if we happen to have another repo called `OurCustom.Repo` that we want to create the database for, we can run this. ```console $ mix ecto.create -r OurCustom.Repo The database for OurCustom.Repo has been created. ``` ### `mix ecto.drop` This task will drop the database specified in our repo. By default it will look for the repo named after our application (the one generated with our app unless we opted out of Ecto). It will not prompt us to check if we're sure we want to drop the database, so do exercise caution. ```console $ mix ecto.drop The database for Hello.Repo has been dropped. ``` ### `mix ecto.gen.migration` Migrations are a programmatic, repeatable way to affect changes to a database schema. Phoenix generators take care of generating migrations for us whenever we create a new context or schema, but if you want to generate a migration from scratch, `mix ecto.gen.migration` has our back. Let's see an example. We simply need to invoke the task with a `snake_case` version of the module name that we want. Preferably, the name will describe what we want the migration to do. ```console $ mix ecto.gen.migration add_comments_table * creating priv/repo/migrations * creating priv/repo/migrations/20150318001628_add_comments_table.exs ``` Notice that the migration's filename begins with a string representation of the date and time the file was created. Let's take a look at the file `ecto.gen.migration` has generated for us at `priv/repo/migrations/20150318001628_add_comments_table.exs`. ```elixir defmodule Hello.Repo.Migrations.AddCommentsTable do use Ecto.Migration def change do end end ``` Notice that there is a single function `change/0` which will handle both forward migrations and rollbacks. We'll define the schema changes that we want using Ecto's handy DSL, and Ecto will figure out what to do depending on whether we are rolling forward or rolling back. Very nice indeed. What we want to do is create a `comments` table with a `body` column, a `word_count` column, and timestamp columns for `inserted_at` and `updated_at`. ```elixir ... def change do create table(:comments) do add :body, :string add :word_count, :integer timestamps(type: :utc_datetime) end end ... ``` For more information on how to modify your database schema please refer to the [Ecto's migration DSL docs](https://hexdocs.pm/ecto_sql/Ecto.Migration.html). For example, to alter an existing schema see the documentation on Ecto’s [`alter/2`](`Ecto.Migration.alter/2`) function. That's it! We're ready to run our migration. ### `mix ecto.migrate` Once we have our migration module ready, we can simply run `mix ecto.migrate` to have our changes applied to the database. We have already used it earlier in this chapter, but let's take it for a spin once more for our newly generated migration. ```console $ mix ecto.migrate [info] == Running Hello.Repo.Migrations.AddCommentsTable.change/0 forward [info] create table comments [info] == Migrated in 0.1s ``` When we first run `ecto.migrate`, it will create a table for us called `schema_migrations`. This will keep track of all the migrations which we run by storing the timestamp portion of the migration's filename. Here's what the `schema_migrations` table looks like. ```console hello_dev=# select * from schema_migrations; version | inserted_at ---------------+--------------------- 20250317170448 | 2025-03-17 21:07:26 20250318001628 | 2025-03-18 01:45:00 (2 rows) ``` When we roll back a migration, `mix ecto.rollback`, to be discussed next, we will remove the record representing this migration from `schema_migrations`. By default, `ecto.migrate` will execute all pending migrations. We can exercise more control over which migrations we run by specifying some options when we run the task. We can specify the number of pending migrations we would like to run with the `-n` or `--step` options. ```console $ mix ecto.migrate -n 2 [info] == Running Hello.Repo.Migrations.CreatePost.change/0 forward [info] create table posts [info] == Migrated in 0.0s [info] == Running Hello.Repo.Migrations.AddCommentsTable.change/0 forward [info] create table comments [info] == Migrated in 0.0s ``` The `--step` option will behave the same way. ```console $ mix ecto.migrate --step 2 ``` The `--to` option will run all migrations up to and including given version. ```console $ mix ecto.migrate --to 20150317170448 ``` ### `mix ecto.rollback` The `mix ecto.rollback` task will reverse the last migration we have run, undoing the schema changes. `ecto.migrate` and `ecto.rollback` are mirror images of each other. ```console $ mix ecto.rollback [info] == Running Hello.Repo.Migrations.AddCommentsTable.change/0 backward [info] drop table comments [info] == Migrated in 0.0s ``` `ecto.rollback` will handle the same options as `ecto.migrate`, so `-n`, `--step`, `-v`, and `--to` will behave as they do for `ecto.migrate`. [`cast/3`]: `Ecto.Changeset.cast/3` [`from/2`]: `Ecto.Query.from/2` [`Repo.delete_all/2`]: `c:Ecto.Repo.delete_all/2` [`Repo.delete/2`]: `c:Ecto.Repo.delete/2` [`Repo.insert_all/3`]: `c:Ecto.Repo.insert_all/3` [`Repo.insert/2`]: `c:Ecto.Repo.insert/2` [`Repo.one/2`]: `c:Ecto.Repo.one/2` [`Repo.update_all/3`]: `c:Ecto.Repo.update_all/3` [`Repo.update/2`]: `c:Ecto.Repo.update/2` [`timestamps/1`]: `Ecto.Migration.timestamps/1` ================================================ FILE: guides/howto/custom_error_pages.md ================================================ # Custom Error Pages New Phoenix projects have two error views called `ErrorHTML` and `ErrorJSON`, which live in `lib/hello_web/controllers/`. The purpose of these views is to handle errors in a general way for each format, from one centralized location. ## The Error Views For new applications, the `ErrorHTML` and `ErrorJSON` views looks like this: ```elixir defmodule HelloWeb.ErrorHTML do use HelloWeb, :html # If you want to customize your error pages, # uncomment the embed_templates/1 call below # and add pages to the error directory: # # * lib/<%= @lib_web_name %>/controllers/error_html/404.html.heex # * lib/<%= @lib_web_name %>/controllers/error_html/500.html.heex # # embed_templates "error_html/*" # The default is to render a plain text page based on # the template name. For example, "404.html" becomes # "Not Found". def render(template, _assigns) do Phoenix.Controller.status_message_from_template(template) end end defmodule HelloWeb.ErrorJSON do # 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 ``` Before we dive into this, let's see what the rendered `404 Not Found` message looks like in a browser. In the development environment, Phoenix will debug errors by default, showing us a very informative debugging page. What we want here, however, is to see what page the application would serve in production. In order to do that, we need to set `debug_errors: false` in `config/dev.exs`. ```elixir import Config config :hello, HelloWeb.Endpoint, ..., debug_errors: false, code_reloader: true, ... ``` After modifying our config file, we need to restart our server in order for this change to take effect. After restarting the server, let's go to [http://localhost:4000/such/a/wrong/path](http://localhost:4000/such/a/wrong/path) for a running local application and see what we get. Ok, that's not very exciting. We get the bare string "Not Found", displayed without any markup or styling. The first question is, where does that error string come from? The answer is right in `ErrorHTML`. ```elixir def render(template, _assigns) do Phoenix.Controller.status_message_from_template(template) end ``` Great, so we have this `render/2` function that takes a template and an `assigns` map, which we ignore. When you call `render(conn, :some_template)` from the controller, Phoenix first looks for a `some_template/1` function on the view module. If no function exists, it falls back to calling `render/2` with the template and format name, such as `"some_template.html"`. In other words, to provide custom error pages, we could simply define a proper `render/2` function clause in `HelloWeb.ErrorHTML`. ```elixir def render("404.html", _assigns) do "Page Not Found" end ``` But we can do even better. Phoenix generates an `ErrorHTML` for us, but it doesn't give us a `lib/hello_web/controllers/error_html` directory. Let's create one now. Inside our new directory, let's add a template named `404.html.heex` and give it some markup – a mixture of our application layout and a new `
` with our message to the user. ```heex Welcome to Phoenix!

Sorry, the page you are looking for does not exist.

``` After you define the template file, remember to remove the equivalent `render/2` clause for that template, as otherwise the function overrides the template. Let's do so for the 404.html clause we have previously introduced in `lib/hello_web/controllers/error_html.ex`. We also need to tell Phoenix to embed our templates into the module: ```diff + embed_templates "error_html/*" - def render("404.html", _assigns) do - "Page Not Found" - end ``` Now, when we go back to [http://localhost:4000/such/a/wrong/path](http://localhost:4000/such/a/wrong/path), we should see a much nicer error page. It is worth noting that we did not render our `404.html.heex` template through our application layout, even though we want our error page to have the look and feel of the rest of our site. This is to avoid circular errors. For example, what happens if our application failed due to an error in the layout? Attempting to render the layout again will just trigger another error. So ideally we want to minimize the amount of dependencies and logic in our error templates, sharing only what is necessary. ## Custom exceptions Elixir provides a macro called `defexception/1` for defining custom exceptions. Exceptions are represented as structs, and structs need to be defined inside of modules. In order to create a custom exception, we need to define a new module. Conventionally, this will have "Error" in the name. Inside that module, we need to define a new exception with `defexception/1`, the file `lib/hello_web.ex` seems like a good place for it. ```elixir defmodule HelloWeb.SomethingNotFoundError do defexception [:message] end ``` You can raise your new exception like this: ```elixir raise HelloWeb.SomethingNotFoundError, "oops" ``` By default, Plug and Phoenix will treat all exceptions as 500 errors. However, Plug provides a protocol called `Plug.Exception` where we are able to customize the status and add actions that exception structs can return on the debug error page. If we wanted to supply a status of 404 for an `HelloWeb.SomethingNotFoundError` error, we could do it by defining an implementation for the `Plug.Exception` protocol like this, in `lib/hello_web.ex`: ```elixir defimpl Plug.Exception, for: HelloWeb.SomethingNotFoundError do def status(_exception), do: 404 def actions(_exception), do: [] end ``` Alternatively, you could define a `plug_status` field directly in the exception struct: ```elixir defmodule HelloWeb.SomethingNotFoundError do defexception [:message, plug_status: 404] end ``` However, implementing the `Plug.Exception` protocol by hand can be convenient in certain occasions, such as when providing actionable errors. ## Actionable errors Exception actions are functions that can be triggered from the error page, and they're basically a list of maps defining a `label` and a `handler` to be executed. As an example, Phoenix will display an error if you have pending migrations and will provide a button on the error page to perform the pending migrations. When `debug_errors` is `true`, they are rendered in the error page as a collection of buttons and follow the format of: ```elixir [ %{ label: String.t(), handler: {module(), function :: atom(), args :: []} } ] ``` If we wanted to return some actions for an `HelloWeb.SomethingNotFoundError` we would implement `Plug.Exception` like this: ```elixir defimpl Plug.Exception, for: HelloWeb.SomethingNotFoundError do def status(_exception), do: 404 def actions(_exception) do [ %{ label: "Run seeds", handler: {Code, :eval_file, ["priv/repo/seeds.exs"]} } ] end end ``` ================================================ FILE: guides/howto/file_uploads.md ================================================ # File Uploads One common task for web applications is uploading files. These files might be images, videos, PDFs, or files of any other type. In order to upload files through an HTML interface, we need a `file` input tag in a multipart form. > #### Looking for the LiveView Uploads guide? {: .neutral} > > This guide explains multipart HTTP file uploads via `Plug.Upload`. > For more information about LiveView file uploads, including direct-to-cloud external uploads on > the client, refer to the [LiveView Uploads guide](https://hexdocs.pm/phoenix_live_view/uploads.html). Plug provides a `Plug.Upload` struct to hold the data from the `file` input. A `Plug.Upload` struct will automatically appear in your request parameters if a user has selected a file when they submit the form. In this guide you will do the following: 1. Configure a multipart form 2. Add a file input element to the form 3. Verify your upload params 4. Manage your uploaded files In the [`Contexts guide`](contexts.md), we generated an HTML resource for products. We can reuse the form we generated there in order to demonstrate how file uploads work in Phoenix. Please refer to that guide for instructions on generating the product resource you will be using here. ### Configure a multipart form The first thing you need to do is change your form into a multipart form. The `HelloWeb.CoreComponents` `form/1` component accepts a `multipart` attribute where you can specify this. Here is the form from `lib/hello_web/controllers/product_html/product_form.html.heex` with that change in place: ```heex <.form :let={f} for={@changeset} action={@action} multipart> ... ``` ### Add a file input Once you have a multipart form, you need a `file` input. Here's how you would do that, also in `product_form.html.heex`: ```heex ... <.input field={f[:photo]} type="file" label="Photo" /> <.button>Save Product ``` When rendered, here is the HTML for the default `HelloWeb.CoreComponents` `input/1` component: ```html
``` Note the `name` attribute of your `file` input. This will create the `"photo"` key in the `product_params` map which will be available in your controller action. This is all from the form side. Now when users submit the form, a `POST` request will route to your `HelloWeb.ProductController` `create/2` action. > #### Should I add photo to my Ecto schema? {: .neutral} > > The photo input does not need to be part of your schema for it to come across in the `product_params`. If you want to persist any properties of the photo in a database, however, you would need to add it to your `Hello.Product` schema. ### Verify your upload params Since you generated an HTML resource, you can now start your server with `mix phx.server`, visit [http://localhost:4000/products/new](http://localhost:4000/products/new), and create a new product with a photo. Before you begin, add `IO.inspect product_params` to the top of your `ProductController.create/2` action in `lib/hello_web/controllers/product_controller.ex`. This will show the `product_params` in your development log so you can get a better sense of what's happening. ```elixir ... def create(conn, %{"product" => product_params}) do IO.inspect product_params ... ``` When you do that, this is what your `product_params` will output in the log: ```elixir %{"title" => "Metaprogramming Elixir", "description" => "Write Less Code, Get More Done (and Have Fun!)", "price" => "15.000000", "views" => "0", "photo" => %Plug.Upload{content_type: "image/png", filename: "meta-cover.png", path: "/var/folders/_6/xbsnn7tx6g9dblyx149nrvbw0000gn/T//plug-1434/multipart-558399-917557-1"}} ``` You have a `"photo"` key which maps to the pre-populated `Plug.Upload` struct representing your uploaded photo. To make this easier to read, focus on the struct itself: ```elixir %Plug.Upload{content_type: "image/png", filename: "meta-cover.png", path: "/var/folders/_6/xbsnn7tx6g9dblyx149nrvbw0000gn/T//plug-1434/multipart-558399-917557-1"} ``` `Plug.Upload` provides the file's content type, original filename, and path to the temporary file which Plug created for you. In this case, `"/var/folders/_6/xbsnn7tx6g9dblyx149nrvbw0000gn/T//plug-1434/"` is the directory created by Plug in which to put uploaded files. The directory will persist across requests. `"multipart-558399-917557-1"` is the name Plug gave to your uploaded file. If you had multiple `file` inputs and if the user selected photos for all of them, you would have multiple files scattered in temporary directories. Plug will make sure all the filenames are unique. > #### Plug.Upload files are temporary {: .info} > > Plug removes uploads from its directory as the request completes. If you need to do anything with this file, you need to do it before then (or [give it away](`Plug.Upload.give_away/3`), but that is outside the scope of this guide). ### Manage your uploaded files Once you have the `Plug.Upload` struct available in your controller, you can perform any operation on it you want. For example, you may want to do one or more of the following: * Check to make sure the file exists with `File.exists?/1` * Copy the file somewhere else on the filesystem with `File.cp/2` * Give the file away to another Elixir process with `Plug.Upload.give_away/3` * Send it to S3 with an external library * Send it back to the client with `Plug.Conn.send_file/5` In a production system, you may want to copy the file to a root directory, such as `/media`. When doing so, it is important to guarantee the names are unique. For instance, if you are allowing users to upload product cover images, you could use the product id to generate a unique name: ```elixir if upload = product_params["photo"] do extension = Path.extname(upload.filename) File.cp(upload.path, "/media/#{product.id}-cover#{extension}") end ``` Then a `Plug.Static` plug could be added in your `lib/my_app_web/endpoint.ex` to serve the files at `"/media"`: ```elixir plug Plug.Static, at: "/uploads", from: "/media" ``` The uploaded file can now be accessed from your browsers using a path such as `"/uploads/1-cover.jpg"`. In practice, there are other concerns you want to handle when uploading files, such validating extensions, encoding names, and so on. Many times, using a library that already handles such cases is preferred. Finally, notice that when there is no data from the `file` input, you get neither the `"photo"` key nor a `Plug.Upload` struct. Here are the `product_params` from the log. ```elixir %{"title" => "Metaprogramming Elixir", "description" => "Write Less Code, Get More Done (and Have Fun!)", "price" => "15.000000", "views" => "0"} ``` ## Configuring upload limits The conversion from the data being sent by the form to an actual `Plug.Upload` is done by the `Plug.Parsers` plug which you can find inside `HelloWeb.Endpoint`: ```elixir # lib/hello_web/endpoint.ex plug Plug.Parsers, parsers: [:urlencoded, :multipart, :json], pass: ["*/*"], json_decoder: Phoenix.json_library() ``` Besides the options above, `Plug.Parsers` accepts other options to control data upload: * `:length` - sets the max body length to read, defaults to `8_000_000` bytes * `:read_length` - set the amount of bytes to read at one time, defaults to `1_000_000` bytes * `:read_timeout` - set the timeout for each chunk received, defaults to `15_000` ms The first option configures the maximum data allowed. The remaining ones configure how much data we expect to read and its frequency. If the client cannot push data fast enough, the connection will be terminated. Phoenix ships with reasonable defaults but you may want to customize it under special circumstances, for example, if you are expecting really slow clients to send large chunks of data. It is also worth pointing out those limits are important as a security mechanism. For example, if you don't set a limit for data upload, attackers could open up thousands of connections to your application and send one byte every 2 minutes, which would take very long to complete while using up all connections to your server. The limits above expect at least a reasonable amount of progress, making attackers' lives a bit harder. ================================================ FILE: guides/howto/swapping_databases.md ================================================ # Swapping Databases Phoenix applications are configured to use PostgreSQL by default, but what if we want to use another database, such as MySQL? In this guide, we'll walk through changing that default whether we are about to create a new application, or whether we have an existing one configured for PostgreSQL. ## Using `phx.new` If we are about to create a new application, configuring our application to use MySQL is easy. We can simply pass the `--database mysql` flag to `phx.new` and everything will be configured correctly. ```console $ mix phx.new hello_phoenix --database mysql ``` This will set up all the correct dependencies and configuration for us automatically. Once we install those dependencies with `mix deps.get`, we'll be ready to begin working with Ecto in our application. ## Within an existing application If we have an existing application, all we need to do is switch adapters and make some small configuration changes. To switch adapters, we need to remove the Postgrex dependency and add a new one for MyXQL instead. Let's open up our `mix.exs` file and do that now. ```elixir defmodule HelloPhoenix.MixProject do use Mix.Project ... # Specifies your project dependencies. # # Type `mix help deps` for examples and options. defp deps do [ {:phoenix, "~> 1.4.0"}, {:phoenix_ecto, "~> 4.4"}, {:ecto_sql, "~> 3.13"}, {:myxql, ">= 0.0.0"}, ... ] end end ``` Next, we need to configure our adapter to use the default MySQL credentials by updating `config/dev.exs`: ```elixir config :hello_phoenix, HelloPhoenix.Repo, username: "root", password: "", database: "hello_phoenix_dev" ``` If we have an existing configuration block for our `HelloPhoenix.Repo`, we can simply change the values to match our new ones. You also need to configure the correct values in the `config/test.exs` and `config/runtime.exs` files as well. The last change is to open up `lib/hello_phoenix/repo.ex` and make sure to set the `:adapter` to `Ecto.Adapters.MyXQL`. Now all we need to do is fetch our new dependency, and we'll be ready to go. ```console $ mix deps.get ``` With our new adapter installed and configured, we're ready to create our database. ```console $ mix ecto.create ``` The database for HelloPhoenix.Repo has been created. We're also ready to run any migrations, or do anything else with Ecto that we may choose. ```console $ mix ecto.migrate [info] == Running HelloPhoenix.Repo.Migrations.CreateUser.change/0 forward [info] create table users [info] == Migrated in 0.2s ``` ## Other options While Phoenix uses the `Ecto` project to interact with the data access layer, there are many other data access options, some even built into the Erlang standard library. [ETS](https://www.erlang.org/doc/man/ets.html) – available in Ecto via [`etso`](https://hexdocs.pm/etso/) – and [DETS](https://www.erlang.org/doc/man/dets.html) are key-value data stores built into [Erlang/OTP](https://www.erlang.org/doc/). Both Elixir and Erlang also have a number of libraries for working with a wide range of popular data stores. The data world is your oyster, but we won't be covering these options in these guides. ================================================ FILE: guides/howto/using_ssl.md ================================================ # Using SSL To prepare an application to serve requests over SSL, we need to add a little bit of configuration and two environment variables. In order for SSL to actually work, we'll need a key file and certificate file from a certificate authority. The environment variables that we'll need are paths to those two files. The configuration consists of a new `https:` key for our endpoint whose value is a keyword list of port, path to the key file, and path to the cert (PEM) file. If we add the `otp_app:` key whose value is the name of our application, Plug will begin to look for them at the root of our application. We can then put those files in our `priv` directory and set the paths to `priv/our_keyfile.key` and `priv/our_cert.crt`. Here's an example configuration from `config/runtime.exs`. ```elixir import Config config :hello, HelloWeb.Endpoint, http: [port: String.to_integer(System.get_env("PORT"))], url: [host: "example.com"], cache_static_manifest: "priv/static/cache_manifest.json", https: [ port: 443, cipher_suite: :strong, otp_app: :hello, keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"), certfile: System.get_env("SOME_APP_SSL_CERT_PATH"), # OPTIONAL Key for intermediate certificates: cacertfile: System.get_env("INTERMEDIATE_CERTFILE_PATH") ] ``` Without the `otp_app:` key, we need to provide absolute paths to the files wherever they are on the filesystem in order for Plug to find them. ```elixir Path.expand("../../../some/path/to/ssl/key.pem", __DIR__) ``` The options under the `https:` key are passed to the Plug adapter, typically `Bandit`, which in turn uses `Plug.SSL` to select the TLS socket options. Please refer to the documentation for [Plug.SSL.configure/1](https://hexdocs.pm/plug/Plug.SSL.html#configure/1) for more information on the available options and their defaults. The [Plug HTTPS Guide](https://hexdocs.pm/plug/https.html) and the [Erlang/OTP ssl](https://www.erlang.org/doc/man/ssl.html) documentation also provide valuable information. ## SSL in Development If you would like to use HTTPS in development, a self-signed certificate can be generated by running: `mix phx.gen.cert`. This requires Erlang/OTP 20 or later. With your self-signed certificate, your development configuration in `config/dev.exs` can be updated to run an HTTPS endpoint: ```elixir config :my_app, MyAppWeb.Endpoint, ... https: [ port: 4001, cipher_suite: :strong, keyfile: "priv/cert/selfsigned_key.pem", certfile: "priv/cert/selfsigned.pem" ] ``` This can replace your `http` configuration, or you can run HTTP and HTTPS servers on different ports. ## Force SSL In many cases, you'll want to force all incoming requests to use SSL by redirecting HTTP to HTTPS. This can be accomplished by setting the `:force_ssl` option in your endpoint configuration. It expects a list of options which are forwarded to `Plug.SSL`. By default, it sets the "strict-transport-security" header in HTTPS requests, forcing browsers to always use HTTPS. For example: ```elixir config :my_app, MyAppWeb.Endpoint, force_ssl: [rewrite_on: [:x_forwarded_proto]] ``` If an unsafe (HTTP) request is sent, the above will redirect to the HTTPS version using the `:host` specified in the `:url` configuration. The `rewrite_on:` key specifies the HTTP header used by a reverse proxy or load balancer in front of the application to indicate whether the request was received over HTTP or HTTPS. To dynamically redirect to the `host` of the current request, set `:host` in the `:force_ssl` configuration to `nil`. In such cases, you must also set `x_forwarded_host` and `x_forwarded_port` if running behind a proxy: ```elixir config :my_app, MyAppWeb.Endpoint, force_ssl: [rewrite_on: [:x_forwarded_proto, :x_forwarded_host, :x_forwarded_port], host: nil] ``` Furthermore, keep in mind `force_ssl` will redirect all requests, except the ones coming from localhost. If your application is doing probeness checks using another origin, such as "127.0.0.1" or an internal IP address, you may need to explicitly exclude them from `force_ssl`: ```elixir config :my_app, MyAppWeb.Endpoint, force_ssl: [rewrite_on: [:x_forwarded_proto], exclude: ["localhost", "127.0.0.1"]] ``` It is important to note that `force_ssl:` is a *compile* time config, so it normally is set in `prod.exs`, it will not work when set from `runtime.exs`. For more information on the implications of offloading TLS to an external element, in particular relating to secure cookies, refer to the [Plug HTTPS Guide](https://hexdocs.pm/plug/https.html#offloading-tls). Keep in mind that the options passed to `Plug.SSL` in that document should be set using the `force_ssl:` endpoint option in a Phoenix application. ## HSTS HSTS, short for 'HTTP Strict-Transport-Security', is a mechanism that allows websites to declare themselves as accessible exclusively through a secure connection (HTTPS). It was introduced to prevent man-in-the-middle attacks that strip SSL/TLS encryption. HSTS causes web browsers to redirect from HTTP to HTTPS and to refuse to connect unless the connection uses SSL/TLS. With `force_ssl: [hsts: true]` set, the `Strict-Transport-Security` header is added with a max-age that defines the duration for which the policy is valid. Modern web browsers will respond to this by redirecting from HTTP to HTTPS, among other consequences. [RFC6797](https://tools.ietf.org/html/rfc6797), which defines HSTS, also specifies that **the browser should keep track of a host's policy and apply it until it expires.** It further specifies that **traffic on any port other than 80 is assumed to be encrypted** as per the policy. While HSTS is recommended in production, it can lead to unexpected behavior when accessing applications on localhost. For instance, accessing an application with HSTS enabled at `https://localhost:4000` leads to a situation where all subsequent traffic from localhost, except for port 80, is expected to be encrypted. This can disrupt traffic to other local servers or proxies running on your computer that are unrelated to your Phoenix application and may not support encrypted traffic. If you inadvertently enable HSTS for localhost, you may need to reset your browser's cache before it will accept HTTP traffic from localhost again. For Chrome: 1. Open the Developer Tools Panel. 2. Click and hold the reload icon next to the address bar to reveal a dropdown menu. 3. Select "Empty Cache and Hard Reload". For Safari: 1. Clear your browser cache. 2. Remove the entry from `~/Library/Cookies/HSTS.plist` or delete the file entirely. 3. Restart Safari. For other browsers, please consult the documentation for HSTS. Alternatively, setting the `:expires` option on `force_ssl` to `0` should expire the entry and disable HSTS. For more information on HSTS options, see [Plug.SSL](https://hexdocs.pm/plug/Plug.SSL.html). ================================================ FILE: guides/howto/writing_a_channels_client.md ================================================ # Writing a Channels Client Client libraries for Phoenix Channels already exist in [several languages](https://hexdocs.pm/phoenix/channels.html#client-libraries), but if you want to write your own, this guide should get you started. It may also be useful as a guide for manual testing with a WebSocket client. ## Overview Because WebSockets are bidirectional, messages can flow in either direction at any time. For this reason, clients typically use callbacks to handle incoming messages whenever they come. A client must join at least one topic to begin sending and receiving messages, and may join any number of topics using the same connection. ## Connecting To establish a WebSocket connection to Phoenix Channels, first make note of the `socket` declaration in the application's `Endpoint` module. For example, if you see: `socket "/mobile", MyAppWeb.MobileSocket`, the path for the initial HTTP request is: [host]:[port]/mobile/websocket?vsn=2.0.0 Passing `&vsn=2.0.0` specifies `Phoenix.Socket.V2.JSONSerializer`, which is built into Phoenix, and which expects and returns messages in the form of lists. You also need to include [the standard header fields for upgrading an HTTP request to a WebSocket connection](https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism) or use an HTTP library that handles this for you; in Elixir, [mint_web_socket](https://hex.pm/packages/mint_web_socket) is an example. Other parameters or headers may be expected or required by the specific `connect/3` function in the application's socket module (in the example above, `MyAppWeb.MobileSocket.connect/3`). ## Message Format The message format is determined by the serializer configured for the application. For these examples, `Phoenix.Socket.V2.JSONSerializer` is assumed. The general format for messages a client sends to a Phoenix Channel is as follows: ``` [join_reference, message_reference, topic_name, event_name, payload] ``` - The `join_reference` is also chosen by the client and should also be a unique value. It only needs to be sent for a `"phx_join"` event; for other messages it can be `null`. It is used as a message reference for `push` messages from the server, meaning those that are not replies to a specific client message. For example, imagine something like "a new user just joined the chat room". - The `message_reference` is chosen by the client and should be a unique value. The server includes it in its reply so that the client knows which message the reply is for. - The `topic_name` must be a known topic for the socket endpoint, and a client must join that topic before sending any messages on it. - The `event_name` must match the first argument of a `handle_in` function on the server channel module. - The `payload` should be a map and is passed as the second argument to that `handle_in` function. There are three events that are understood by every Phoenix application. First, `phx_join` is used join a channel. For example, to join the `miami:weather` channel: ```json ["0", "0", "miami:weather", "phx_join", {"some": "param"}] ``` Second, `phx_leave` is used to leave a channel. For example, to leave the `miami:weather` channel: ```json [null, "1", "miami:weather", "phx_leave", {}] ``` Third, `heartbeat` is used to maintain the WebSocket connection. For example: ```json [null, "2", "phoenix", "heartbeat", {}] ``` The `heartbeat` message is only needed when no other messages are being sent and prevents Phoenix from closing the connection; the exact `:timeout` is configured in the application's `Endpoint` module. Other allowed messages depend on the Phoenix application. For example, if the Channel serving the `miami:weather` can handle a `report_emergency` event: ```elixir def handle_in("report_emergency", payload, socket) do MyApp.Emergencies.report(payload) # or whatever {:reply, :ok, socket} end ``` ...a client could send: ```json [null, "3", "miami:weather", "report_emergency", {"category": "sharknado"}] ``` ================================================ FILE: guides/introduction/community.md ================================================ # Community The Elixir and Phoenix communities are friendly and welcoming. All questions and comments are valuable, so please come join the discussion! There are a number of places to connect with community members at all experience levels. * We're on Libera IRC in the [\#elixir](https://web.libera.chat/?channels=#elixir) channel. * Feel free to join and check out the #phoenix channel on [Discord](https://discord.gg/elixir). * Read about [bug reports](https://github.com/phoenixframework/phoenix/blob/main/CONTRIBUTING.md#bug-reports) or open an issue in the Phoenix [issue tracker](https://github.com/phoenixframework/phoenix/issues). * Ask or answer questions about Phoenix on [Elixir Forum](https://elixirforum.com/c/phoenix-forum) or [Stack Overflow](https://stackoverflow.com/questions/tagged/phoenix-framework). * Follow the Phoenix Framework on [Twitter](https://twitter.com/elixirphoenix). ## Security For information about security patches and how to report a vulnerability in Phoenix, see the [security policy.](https://github.com/phoenixframework/phoenix/security) To learn about how to secure a web application written with Phoenix, see the [security documentation page.](/guides/security.md) The Erlang Ecosystem Foundation also publishes in-depth documents which are relevant for Erlang, Elixir, and Phoenix developers. These include: * [Web Application Security Best Practices for BEAM languages](https://security.erlef.org/web_app_security_best_practices_beam/) * [Secure Coding and Deployment Hardening Guidelines](https://security.erlef.org/secure_coding_and_deployment_hardening/) ## Books * [Programming Phoenix LiveView - Interactive Elixir Web Programming Without Writing Any JavaScript - 2023 (by Bruce Tate and Sophie DeBenedetto)](https://pragprog.com/titles/liveview/programming-phoenix-liveview/) * [Phoenix Tutorial (Phoenix 1.6)](https://thephoenixtutorial.org/) - [Free to read online](https://thephoenixtutorial.org/book) * [Real-Time Phoenix - Build Highly Scalable Systems with Channels (by Stephen Bussey - 2020)](https://pragprog.com/titles/sbsockets/real-time-phoenix/) * [Programming Phoenix 1.4 (by Bruce Tate, Chris McCord, and José Valim - 2019)](https://pragprog.com/titles/phoenix14/programming-phoenix-1-4/) * [Phoenix in Action (by Geoffrey Lessel - 2019)](https://manning.com/books/phoenix-in-action) * [Phoenix Inside Out - Book Series (by Shankar Dhanasekaran - 2017)](https://shankardevy.com/phoenix-book/). First book of the series Mastering Phoenix Framework is [free to read online](https://shankardevy.com/phoenix-inside-out-mpf/) * [Functional Web Development with Elixir, OTP, and Phoenix Rethink the Modern Web App (by Lance Halvorsen - 2017)](https://pragprog.com/titles/lhelph/functional-web-development-with-elixir-otp-and-phoenix/) ## Screencasts/Courses * [Full-Stack Phoenix Course (by The Pragmatic Studio - 2025)](https://pragmaticstudio.com/courses/phoenix) * [Free Bootcamp: Fullstack Elixir and Phoenix (by TechSchool - 2024)](https://techschool.dev/en/bootcamps/fullstack-elixir-and-phoenix) * [Learn Phoenix LiveView (by George Arrowsmith - 2024)](https://phoenixliveview.com) * [Phoenix LiveView Course (by The Pragmatic Studio - 2023)](https://pragmaticstudio.com/courses/phoenix-liveview) * [Build It With Phoenix video course (by Geoffrey Lessel - 2023)](https://builditwithphoenix.com) * [Free Crash Course: Phoenix LiveView (by Productive Programmer - 2023)](https://www.productiveprogrammer.com/learn-phoenix-liveview-free) * [Phoenix on Rails: Elixir and Phoenix for Ruby on Rails developers (by George Arrowsmith - 2023)](https://phoenixonrails.com) * [Groxio LiveView: Self Study Program (by Bruce Tate - 2020)](https://grox.io/language/liveview/course) * [Alchemist Camp: Learn Elixir and Phoenix by building (2018-2022)](https://alchemist.camp/episodes) * [The Complete Elixir and Phoenix Bootcamp Master Functional Programming Techniques with Elixir and Phoenix while Learning to Build Compelling Web Applications (by Stephen Grider - 2017)](https://www.udemy.com/the-complete-elixir-and-phoenix-bootcamp-and-tutorial/) * [Discover Elixir & Phoenix (by Tristan Edwards - 2017)](https://www.ludu.co/course/discover-elixir-phoenix) * [Phoenix Framework Tutorial (by Tensor Programming - 2017)](https://www.youtube.com/watch?v=irDC1nWKhZ8&index=6&list=PLJbE2Yu2zumAgKjSPyFtvYjP5LqgzafQq) * [Getting Started with Phoenix (by Pluralsight - 2017)](https://www.pluralsight.com/courses/phoenix-getting-started) * [LearnPhoenix.tv: Learn how to Build Fast, Dependable Web Apps with Phoenix (2017)](https://www.learnphoenix.tv/) * [LearnPhoenix.io: Build Scalable, Real-Time Apps with Phoenix, React, and React Native (2016)](https://www.learnphoenix.io/) ================================================ FILE: guides/introduction/installation.md ================================================ # Installation In order to build a Phoenix application, we will need a few dependencies installed in our Operating System: * the Erlang VM and the Elixir programming language * a database - Phoenix recommends PostgreSQL, but you can pick others or not use a database at all * and other optional packages. Please take a look at this list and make sure to install anything necessary for your system. Having dependencies installed in advance can prevent frustrating problems later on. If you just want to get started quickly, the [Up and Running](up_and_running.md) page includes a link to Phoenix Express, which will get Erlang, Elixir and Phoenix installed and running in seconds. ## Elixir 1.15 or later Phoenix is written in Elixir, and our application code will also be written in Elixir. We won't get far in a Phoenix app without it! The Elixir site maintains a great [Installation Page](https://elixir-lang.org/install.html) to help. ## Erlang 24 or later Elixir code compiles to Erlang byte code to run on the Erlang virtual machine. Without Erlang, Elixir code has no virtual machine to run on, so we need to install Erlang as well. When we install Elixir using instructions from the Elixir [Installation Page](https://elixir-lang.org/install.html), we will usually get Erlang too. If Erlang was not installed along with Elixir, please see the [Erlang Instructions](https://elixir-lang.org/install.html#installing-erlang) section of the Elixir Installation Page for instructions. ## Phoenix To check that we are on Elixir 1.15 and Erlang 24 or later, run: ```console elixir -v Erlang/OTP 24 [erts-12.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false] [dtrace] Elixir 1.15.0 ``` Once we have Elixir and Erlang, we are ready to install the Phoenix application generator: ```console $ mix archive.install hex phx_new ``` The `phx.new` generator is now available to generate new applications in the next guide, called [Up and Running](up_and_running.html). The flags mentioned below are command line options to the generator; see all available options by calling `mix help phx.new`. ## PostgreSQL PostgreSQL is a relational database server. Phoenix configures applications to use it by default, but we can switch to MySQL, MSSQL, or SQLite3 by passing the `--database` flag when creating a new application. In order to talk to databases, Phoenix applications use another Elixir package, called [Ecto](https://github.com/elixir-ecto/ecto). If you don't plan to use databases in your application, you can pass the `--no-ecto` flag. However, if you are just getting started with Phoenix, we recommend you to install PostgreSQL and make sure it is running. The PostgreSQL wiki has [installation guides](https://wiki.postgresql.org/wiki/Detailed_installation_guides) for a number of different systems. ## inotify-tools (for Linux users) Phoenix provides a very handy feature called Live Reloading. As you change your views or your assets, it automatically reloads the page in the browser. In order for this functionality to work, you need a filesystem watcher. macOS and Windows users already have a filesystem watcher, but Linux users must install inotify-tools. Please consult the [inotify-tools wiki](https://github.com/rvoicilas/inotify-tools/wiki) for distribution-specific installation instructions. ## Summary At the end of this section, you must have installed Elixir, Hex, Phoenix, and PostgreSQL. Now that we have everything installed, let's create our first Phoenix application and get [up and running](up_and_running.html). ================================================ FILE: guides/introduction/overview.md ================================================ # Overview Phoenix is a web development framework written in Elixir which implements the server-side Model View Controller (MVC) pattern. Many of its components and concepts will seem familiar to those of us with experience in other web frameworks like Ruby on Rails or Python's Django. Phoenix provides the best of both worlds - high developer productivity _and_ high application performance. It also has some interesting new twists like channels for implementing realtime features and pre-compiled templates for blazing speed. If you are already familiar with Elixir, great! If not, there are a number of places to learn. The [Elixir guides](https://hexdocs.pm/elixir/introduction.html) and the [Elixir learning resources page](https://elixir-lang.org/learning.html) are two great places to start. The guides that you are currently looking at provide an overview of all parts that make Phoenix. Here is a rundown of what they provide: * Introduction - the guides you are currently reading. They will cover how to get your first application up and running * Guides - in-depth guides covering the main components in Phoenix and Phoenix applications * Data modelling - building the initial features of an e-commerce application to learn about more data modelling with Phoenix * Authn and Authz - learn how to use the tools Phoenix provides for authentication and authorization * Real-time components - in-depth guides covering Phoenix's built-in real-time components * Testing - in-depth guides about testing * Deployment - in-depth guides about deployment * How-to's - a collection of articles on how to achieve certain things with Phoenix If you would prefer to read these guides as an EPUB, [click here!](Phoenix.epub) Note, these guides are not a step-by-step introduction to Phoenix. If you want a more structured approach to learning the framework, we have a large community and many books, courses, and screencasts available. See [our community page](community.html) for a complete list. [Let's get Phoenix installed](installation.html). ================================================ FILE: guides/introduction/packages_glossary.md ================================================ # Packages Glossary By default, Phoenix applications depend on several packages with different purposes. This page is a quick reference of the different packages you may work with as a Phoenix developer. The main packages are: * [Ecto](https://hexdocs.pm/ecto) - a language integrated query and database wrapper * [Phoenix](https://hexdocs.pm/phoenix) - the Phoenix web framework (these docs) * [Phoenix LiveView](https://hexdocs.pm/phoenix_live_view) - build rich, real-time user experiences with server-rendered HTML. The LiveView project also defines [`Phoenix.Component`](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html) and [the HEEx template engine](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#sigil_H/2), used for rendering HTML content in both regular and real-time applications * [Plug](https://hexdocs.pm/plug) - specification and conveniences for building composable modules web applications. This is the package responsible for the connection abstraction and the regular request- response life-cycle You will also work with the following: * [ExUnit](https://hexdocs.pm/ex_unit) - Elixir's built-in test framework * [Gettext](https://hexdocs.pm/gettext) - internationalization and localization through [`gettext`](https://www.gnu.org/software/gettext/) * [Swoosh](https://hexdocs.pm/swoosh) - a library for composing, delivering and testing emails, also used by `mix phx.gen.auth` When peeking under the covers, you will find these libraries play an important role in Phoenix applications: * [Phoenix HTML](https://hexdocs.pm/phoenix_html) - building blocks for working with HTML and forms safely * [Phoenix Ecto](https://hex.pm/packages/phoenix_ecto) - plugs and protocol implementations for using phoenix with ecto * [Phoenix PubSub](https://hexdocs.pm/phoenix_pubsub) - a distributed pub/sub system with presence support When it comes to instrumentation and monitoring, check out: * [Phoenix LiveDashboard](https://hexdocs.pm/phoenix_live_dashboard) - real-time performance monitoring and debugging tools for Phoenix developers * [Telemetry Metrics](https://hexdocs.pm/telemetry_metrics) - common interface for defining metrics based on Telemetry events ================================================ FILE: guides/introduction/up_and_running.md ================================================ # Up and Running There are two mechanisms to start a new Phoenix application: the express option, supported on some OSes, and via `mix phx.new`. Let's check it out. ## Phoenix Express A single command will get you up and running in seconds: For macOS/Ubuntu: ```bash $ curl https://new.phoenixframework.org/myapp | sh ``` For Windows PowerShell: ```bash curl.exe -fsSO https://new.phoenixframework.org/myapp.bat; .\myapp.bat ``` The above will install Erlang, Elixir, and Phoenix, and generate a fresh Phoenix application. It will also automatically pick one of PostgreSQL or MySQL as the database, and fallback to SQLite if none of them are available. Once the command above completes, it will open up a Phoenix application, with the steps necessary to complete your installation. Note your Phoenix application name is taken from the path. If your operating system is not supported, or the command above fails, don't fret! You can still start your Phoenix application using `mix phx.new`. ## Via `mix phx.new` In order to create a new Phoenix application, you will need to install Erlang, Elixir, and Phoenix. See the [Installation Guide](installation.html) for more information. If you share your application with someone, they will also need to follow the Installation Guide steps to set it all up. Once you are ready, you can run `mix phx.new` from any directory in order to bootstrap our Phoenix application. Phoenix will accept either an absolute or relative path for the directory of our new project. Assuming that the name of our application is `hello`, let's run the following command: ```console $ mix phx.new hello ``` > By default, `mix phx.new` includes a number of optional dependencies, for example: > > - [Ecto](ecto.html) for communicating with a data store, such as PostgreSQL, MySQL, and others. You can skip this with `--no-ecto`. > > - [Phoenix.HTML](https://hexdocs.pm/phoenix_html/Phoenix.HTML.html), [TailwindCSS](https://tailwindcss.com), and [Esbuild](https://esbuild.github.io) for HTML applications. You can skip them with the `--no-html` and `--no-assets` flags. > > - [Phoenix.LiveView](https://hexdocs.pm/phoenix_live_view/) for building realtime and interactive web applications. You can skip this with `--no-live`. > > Run `mix help phx.new` to learn all options. ```console mix phx.new hello * creating hello/config/config.exs * creating hello/config/dev.exs * creating hello/config/prod.exs ... Fetch and install dependencies? [Yn] ``` Phoenix generates the directory structure and all the files we will need for our application. > Phoenix promotes the usage of git as version control software: among the generated files we find a `.gitignore`. We can `git init` our repository, and immediately add and commit all that hasn't been marked ignored. When it's done, it will ask us if we want it to install our dependencies for us. Let's say yes to that. ```console Fetch and install dependencies? [Yn] Y * running mix deps.get * running mix assets.setup * running mix deps.compile We are almost there! The following steps are missing: $ cd hello Then configure your database in config/dev.exs and run: $ mix ecto.create Start your Phoenix app with: $ mix phx.server You can also run your app inside IEx (Interactive Elixir) as: $ iex -S mix phx.server ``` Once our dependencies are installed, the task will prompt us to change into our project directory and start our application. Phoenix assumes that our PostgreSQL database will have a `postgres` user account with the correct permissions and a password of "postgres". Let's give it a try. First, we'll `cd` into the `hello/` directory we've just created: ```console $ cd hello ``` Now we'll create our database: ```console $ mix ecto.create Compiling 13 files (.ex) Generated hello app The database for Hello.Repo has been created ``` In case the database could not be created, see [our Ecto section on Mix tasks](ecto.html#mix-tasks) or run `mix help ecto.create`. And finally, we'll start the Phoenix server: ```console $ mix phx.server [info] Running HelloWeb.Endpoint with Bandit 1.5.7 at 127.0.0.1:4000 (http) [info] Access HelloWeb.Endpoint at http://localhost:4000 [watch] build finished, watching for changes... ... ``` If we choose not to have Phoenix install our dependencies when we generate a new application, the `mix phx.new` task will prompt us to take the necessary steps when we do want to install them. ```console Fetch and install dependencies? [Yn] n We are almost there! The following steps are missing: $ cd hello $ mix deps.get Then configure your database in config/dev.exs and run: $ mix ecto.create Start your Phoenix app with: $ mix phx.server You can also run your app inside IEx (Interactive Elixir) as: $ iex -S mix phx.server ``` By default, Phoenix accepts requests on port 4000. If we point our favorite web browser at [http://localhost:4000](http://localhost:4000), we should see the Phoenix Framework welcome page. Phoenix Welcome Page If your screen looks like the image above, congratulations! You now have a working Phoenix application. In case you can't see the page above, try accessing it via [http://127.0.0.1:4000](http://127.0.0.1:4000) and later make sure your OS has defined "localhost" as "127.0.0.1". To stop it, we hit `ctrl-c` twice. Now you are ready to explore the world provided by Phoenix! See [our community page](community.html) for books, screencasts, courses, and more. Alternatively, you can continue reading these guides to have a quick introduction into all the parts that make your Phoenix application. If that's the case, you can read the guides in any order or start with our guide that explains the [Phoenix directory structure](directory_structure.html). ================================================ FILE: guides/json_and_apis.md ================================================ # JSON and APIs > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [Controllers guide](controllers.html). You can also use the Phoenix Framework to build [Web APIs](https://en.wikipedia.org/wiki/Web_API). By default Phoenix supports JSON but you can bring any other rendering format you desire. ## The JSON API For this guide let's create a simple JSON API to store our favourite links, that will support all the CRUD (Create, Read, Update, Delete) operations out of the box. For this guide, we will use Phoenix generators to scaffold our API infrastructure: ```console mix phx.gen.json Urls Url urls link:string title:string * creating lib/hello_web/controllers/url_controller.ex * creating lib/hello_web/controllers/url_json.ex * creating lib/hello_web/controllers/changeset_json.ex * creating test/hello_web/controllers/url_controller_test.exs * creating lib/hello_web/controllers/fallback_controller.ex * creating lib/hello/urls/url.ex * creating priv/repo/migrations/20221129120234_create_urls.exs * creating lib/hello/urls.ex * injecting lib/hello/urls.ex * creating test/hello/urls_test.exs * injecting test/hello/urls_test.exs * creating test/support/fixtures/urls_fixtures.ex * injecting test/support/fixtures/urls_fixtures.ex ``` We will break those files into four categories: * Files in `lib/hello_web` responsible for effectively rendering JSON * Files in `lib/hello` responsible for defining our context and logic to persist links to the database * Files in `priv/repo/migrations` responsible for updating our database * Files in `test` to test our controllers and contexts In this guide, we will explore only the first category of files. To learn more about how Phoenix stores and manage data, check out [the Ecto guide](ecto.md) and [the Contexts guide](contexts.md) for more information. We also have a whole section dedicated to testing. At the end, the generator asks us to add the `/url` resource to our `:api` scope in `lib/hello_web/router.ex`: ```elixir scope "/api", HelloWeb do pipe_through :api resources "/urls", UrlController, except: [:new, :edit] end ``` The API scope uses the `:api` pipeline, which will run specific steps such as ensuring the client can handle JSON responses. Then we need to update our repository by running migrations: ```console $ mix ecto.migrate ``` ### Trying out the JSON API Before we go ahead and change those files, let's take a look at how our API behaves from the command line. First, we need to start the server: ```console $ mix phx.server ``` Next, let's make a smoke test to check our API is working with: ```console $ curl -i http://localhost:4000/api/urls ``` If everything went as planned we should get a `200` response: ```console HTTP/1.1 200 OK cache-control: max-age=0, private, must-revalidate content-length: 11 content-type: application/json; charset=utf-8 date: Fri, 06 May 2022 21:22:42 GMT server: Cowboy x-request-id: Fuyg-wMl4S-hAfsAAAUk {"data":[]} ``` We didn't get any data because we haven't populated the database with any yet. So let's add some links: ```console $ curl -iX POST http://localhost:4000/api/urls \ -H 'Content-Type: application/json' \ -d '{"url": {"link":"https://phoenixframework.org", "title":"Phoenix Framework"}}' $ curl -iX POST http://localhost:4000/api/urls \ -H 'Content-Type: application/json' \ -d '{"url": {"link":"https://elixir-lang.org", "title":"Elixir"}}' ``` Now we can retrieve all links: ```console $ curl -i http://localhost:4000/api/urls ``` Or we can just retrieve a link by its `id`: ```console $ curl -i http://localhost:4000/api/urls/1 ``` Next, we can update a link with: ```console $ curl -iX PUT http://localhost:4000/api/urls/2 \ -H 'Content-Type: application/json' \ -d '{"url": {"title":"Elixir Programming Language"}}' ``` The response should be a `200` with the updated link in the body. Finally, we need to try out the removal of a link: ```console $ curl -iX DELETE http://localhost:4000/api/urls/2 \ -H 'Content-Type: application/json' ``` A `204` response should be returned to indicate the successful removal of the link. ## Rendering JSON To understand how to render JSON, let's start with the `index` action from `UrlController` defined at `lib/hello_web/controllers/url_controller.ex`: ```elixir def index(conn, _params) do urls = Urls.list_urls() render(conn, :index, urls: urls) end ``` As we can see, this is not any different from how Phoenix renders HTML templates. We call `render/3`, passing the connection, the template we want our views to render (`:index`), and the data we want to make available to our views. Phoenix typically uses one view per rendering format. When rendering HTML, we would use `UrlHTML`. Now that we are rendering JSON, we will find a `UrlJSON` view collocated with the template at `lib/hello_web/controllers/url_json.ex`. Let's open it up: ```elixir defmodule HelloWeb.UrlJSON do alias Hello.Urls.Url @doc """ Renders a list of urls. """ def index(%{urls: urls}) do %{data: for(url <- urls, do: data(url))} end @doc """ Renders a single url. """ def show(%{url: url}) do %{data: data(url)} end defp data(%Url{} = url) do %{ id: url.id, link: url.link, title: url.title } end end ``` This view is very simple. The `index` function receives all URLs, and converts them into a list of maps. Those maps are placed inside the data key at the root, exactly as we saw when interfacing with our application from `cURL`. In other words, our JSON view converts our complex data into simple Elixir data-structures. Once our view layer returns, Phoenix uses the `Jason` library to encode JSON and send the response to the client. If you explore the remaining controller, you will learn the `show` action is similar to the `index` one. For `create`, `update`, and `delete` actions, Phoenix uses one other important feature, called "Action fallback". ## Reading request data As we've seen in [Request life-cycle](request_lifecycle.html), all controller actions take two arguments, `conn` and `params`. Plug automatically parses path parameters, query parameters and the request body into the `params` argument. ### Minimal example Let's consider this minimal setup, with three API routes (`lib/hello_web/router.ex`): ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :api do plug :accepts, ["json"] end scope "/api", HelloWeb do pipe_through :api get "/", HelloController, :show get "/:name", HelloController, :show post "/", HelloController, :show end end ``` A controller with a single action (`lib/hello_web/controllers/hello_controller.ex`): ```elixir defmodule HelloWeb.HelloController do use HelloWeb, :controller def show(conn, params) do render(conn, :greet, params) end end ``` and a JSON view (`lib/hello_web/controllers/hello_json.ex`): ```elixir defmodule HelloWeb.HelloJSON do def greet(%{"name" => name}) do %{greeting: "Hello #{name}!"} end end ``` This simple setup can process all of the following requests: ```console $ curl http://localhost:4000/api/world $ curl http://localhost:4000/api?name=world $ curl -iX POST http://localhost:4000/api \ -H 'Content-Type: application/json' \ -d '{"name": "world"}' ``` In the exact same way: `Hello world!` ### Request data is merged Since all data is merged under a single map, providing more than one source of data (such as both a path parameter and a JSON body, or a query parameter and a form), will result in **fields with the same name overriding each other.** The priority is as follows: `Path Parameters > Body (any kind) > Query Parameters` Following our last example, lets add another POST request handler which accepts a path parameter: ```elixir scope "/api", HelloWeb do pipe_through :api get "/", HelloController, :show get "/:name", HelloController, :show post "/", HelloController, :show post "/:name", HelloController, :show # New route # ^^^^^ New parameter end ``` Now consider the following requests: ```console $ curl -iX POST http://localhost:4000/api/name1?name=name3 \ -H 'Content-Type: application/json' \ -d '{"name": "name2"}' $ curl -iX POST http://localhost:4000/api?name=name3 \ -H 'Content-Type: application/json' \ -d '{"name": "name2"}' $ curl -iX POST http://localhost:4000/api?name=name3 ``` They would return, respectively, `Hello name1!` (Path parameter), `Hello name2!` (Request body) and `Hello name3!` (Query parameter). You can access those parameters individually if desired via `conn.path_params`, `conn.body_params`, and `conn.query_params` respectively. ## Action fallback Action fallback allows us to centralize error handling code in plugs, which are called when a controller action fails to return a [`%Plug.Conn{}`](`t:Plug.Conn.t/0`) struct. These plugs receive both the `conn` which was originally passed to the controller action along with the return value of the action. Let's say we have a `show` action which uses [`with`](`with/1`) to fetch a blog post and then authorize the current user to view that blog post. In this example we might expect `fetch_post/1` to return `{:error, :not_found}` if the post is not found and `authorize_user/3` might return `{:error, :unauthorized}` if the user is unauthorized. We could use our `ErrorHTML` and `ErrorJSON` views which are generated by Phoenix for every new application to handle these error paths accordingly: ```elixir defmodule HelloWeb.MyController do use Phoenix.Controller def show(conn, %{"id" => id}, current_user) do with {:ok, post} <- fetch_post(id), :ok <- authorize_user(current_user, :view, post) do render(conn, :show, post: post) else {:error, :not_found} -> conn |> put_status(:not_found) |> put_view(html: HelloWeb.ErrorHTML, json: HelloWeb.ErrorJSON) |> render(:"404") {:error, :unauthorized} -> conn |> put_status(403) |> put_view(html: HelloWeb.ErrorHTML, json: HelloWeb.ErrorJSON) |> render(:"403") end end end ``` Now imagine you may need to implement similar logic for every controller and action handled by your API. This would result in a lot of repetition. Instead we can define a module plug which knows how to handle these error cases specifically. Since controllers are module plugs, let's define our plug as a controller: ```elixir defmodule HelloWeb.MyFallbackController do use Phoenix.Controller def call(conn, {:error, :not_found}) do conn |> put_status(:not_found) |> put_view(json: HelloWeb.ErrorJSON) |> render(:"404") end def call(conn, {:error, :unauthorized}) do conn |> put_status(403) |> put_view(json: HelloWeb.ErrorJSON) |> render(:"403") end end ``` Then we can reference our new controller as the `action_fallback` and simply remove the `else` block from our `with`: ```elixir defmodule HelloWeb.MyController do use Phoenix.Controller action_fallback HelloWeb.MyFallbackController def show(conn, %{"id" => id}, current_user) do with {:ok, post} <- fetch_post(id), :ok <- authorize_user(current_user, :view, post) do render(conn, :show, post: post) end end end ``` Whenever the `with` conditions do not match, `HelloWeb.MyFallbackController` will receive the original `conn` as well as the result of the action and respond accordingly. ## FallbackController and ChangesetJSON With this knowledge in hand, we can explore the `FallbackController` (`lib/hello_web/controllers/fallback_controller.ex`) generated by `mix phx.gen.json`. In particular, it handles one clause (the other is generated as an example): ```elixir def call(conn, {:error, %Ecto.Changeset{} = changeset}) do conn |> put_status(:unprocessable_entity) |> put_view(json: HelloWeb.ChangesetJSON) |> render(:error, changeset: changeset) end ``` The goal of this clause is to handle the `{:error, changeset}` return types from the `HelloWeb.Urls` context and render them into rendered errors via the `ChangesetJSON` view. Let's open up `lib/hello_web/controllers/changeset_json.ex` to learn more: ```elixir defmodule HelloWeb.ChangesetJSON do @doc """ Renders changeset errors. """ def error(%{changeset: changeset}) do # When encoded, the changeset returns its errors # as a JSON object. So we just pass it forward. %{errors: Ecto.Changeset.traverse_errors(changeset, &translate_error/1)} end end ``` As we can see, it will convert the errors into a data structure, which will be rendered as JSON. The changeset is a data structure responsible for casting and validating data. For our example, it is defined in `Hello.Urls.Url.changeset/1`. Let's open up `lib/hello/urls/url.ex` and see its definition: ```elixir @doc false def changeset(url, attrs) do url |> cast(attrs, [:link, :title]) |> validate_required([:link, :title]) end ``` As you can see, the changeset requires both link and title to be given. This means we can try posting a url with no link and title and see how our API responds: ```console $ curl -iX POST http://localhost:4000/api/urls \ -H 'Content-Type: application/json' \ -d '{"url": {}}' {"errors": {"link": ["can't be blank"], "title": ["can't be blank"]}} ``` Feel free to modify the `changeset` function and see how your API behaves. ## API-only applications In case you want to generate a Phoenix application exclusively for APIs, you can pass several options when invoking `mix phx.new`. Let's check which `--no-*` flags we need to use to not generate the scaffolding that isn't necessary on our Phoenix application for the REST API. From your terminal run: ```console $ mix help phx.new ``` The output should contain the following: ```text • --no-assets - equivalent to --no-esbuild and --no-tailwind • --no-dashboard - do not include Phoenix.LiveDashboard • --no-ecto - do not generate Ecto files • --no-esbuild - do not include esbuild dependencies and assets. We do not recommend setting this option, unless for API only applications, as doing so requires you to manually add and track JavaScript dependencies • --no-gettext - do not generate gettext files • --no-html - do not generate HTML views • --no-live - comment out LiveView socket setup in your Endpoint and assets/js/app.js. Automatically disabled if --no-html is given • --no-mailer - do not generate Swoosh mailer files • --no-tailwind - do not include tailwind dependencies and assets. The generated markup will still include Tailwind CSS classes, those are left-in as reference for the subsequent styling of your layout and components ``` The `--no-html` is the obvious one we want to use when creating any Phoenix application for an API in order to leave out all the unnecessary HTML scaffolding. You may also pass `--no-assets`, if you don't want any of the asset management bit, `--no-gettext` if you don't support internationalization, and so on. So, in order to generate a simple API called **Hello**, without any frontend, database connection, internationalization or mailing service, you can provide the following flags: ``` $ mix phx.new hello --no-assets --no-dashboard --no-ecto --no-gettext --no-html --no-mailer ``` This still includes the Telemetry, PubSub and DNS Cluster modules by default, which you can remove manually if necessary. Also bear in mind that nothing stops you to have a backend that supports simultaneously the REST API and a Web App (HTML, assets, internationalization and sockets). ================================================ FILE: guides/live_view.md ================================================ # LiveView > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [request life-cycle guide](request_lifecycle.html). We've already seen how the typical request lifecycle in Phoenix works: a request is matched in the router, a controller handles the request and turns to a view to return a response in the correct format. But what if we want to build interactive pages? In a typical server rendered application, changing the content of the page either needs a form submission rendering the new page, or moving application logic to the client (JavaScript frameworks like jQuery, React, Vue, etc.) and building an API interface for the client to talk to. Phoenix LiveView offers a different approach, keeping all the state on the server while providing rich, real-time user experiences with server-rendered HTML. It's an alternative to client-side JavaScript frameworks that allows you to build dynamic, interactive applications with minimal JavaScript code on the client. ## What is a LiveView? LiveViews are processes that receive events, update their state, and render updates to a page as diffs. The LiveView programming model is declarative: instead of saying "once event X happens, change Y on the page", events in LiveView are regular messages which may cause changes to the state. Once the state changes, the LiveView will re-render the relevant parts of its HTML template and push it to the browser, which updates the page in the most efficient manner. LiveView state is nothing more than functional and immutable Elixir data structures. The events are either internal application messages (usually emitted by `Phoenix.PubSub`) or sent by the client/browser. Every LiveView is first rendered statically as part of a regular HTTP request, which provides quick times for "First Meaningful Paint", in addition to helping search and indexing engines. A persistent connection is then established between the client and server to exchange events and changes to the page. This allows LiveView applications to react faster to user events as there is less work to be done and less data to be sent compared to stateless requests that have to authenticate, decode, load, and encode data on every request. You can think of LiveView as "diffs over the wire". ## LiveView vs Controller + View While Phoenix controllers and LiveViews serve similar purposes in handling user interactions, they operate very differently: ### Controller + View - Controllers handle each HTTP request-response pair as separate transactions - Each page load or form submission requires a full request/response cycle - Controllers are stateless, with data stored externally (database, session) - Views are separate modules that render templates with the data from controllers - Page updates and dynamic interactions require either full page reloads or custom client-side JavaScript code ### LiveView approach - Initial page load uses the regular request lifecycle, but then establishes a bidirectional connection using [Phoenix Channels](channels.md) - A LiveView process maintains state throughout user interaction - State changes automatically trigger re-renders of only the changed parts of the page - Events flow through the persistent connection instead of separate HTTP requests - Minimal JavaScript is required for interactive features LiveViews combine the concerns of controllers and views into a more unified model. ## Basic example LiveView is included by default in new Phoenix applications. Let's see a simple example: ```elixir defmodule MyAppWeb.ThermostatLive do use MyAppWeb, :live_view def render(assigns) do ~H""" Current temperature: {@temperature}°F """ end def mount(_params, _session, socket) do temperature = 70 # Let's assume a fixed temperature for now {:ok, assign(socket, :temperature, temperature)} end def handle_event("inc_temperature", _params, socket) do {:noreply, update(socket, :temperature, &(&1 + 1))} end end ``` This LiveView demonstrates the core lifecycle: 1. The `mount/3` callback initializes state when the LiveView starts 2. The `render/1` function defines what is displayed using [HEEx templates](components.md) 3. The `handle_event/3` callback responds to events from the client To wire this up in your router: ```elixir defmodule MyAppWeb.Router do use MyAppWeb, :router pipeline :browser do ... end scope "/", MyAppWeb do pipe_through :browser ... live "/thermostat", ThermostatLive end end ``` Once the LiveView is rendered, a regular HTML response is sent. In your app.js file, you should find the following: ```javascript import {Socket} from "phoenix" import {LiveSocket} from "phoenix_live_view" let csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content") let liveSocket = new LiveSocket("/live", Socket, {params: {_csrf_token: csrfToken}}) liveSocket.connect() ``` Now the JavaScript client will connect over WebSockets and `mount/3` will be invoked inside a spawned LiveView process. ## Key concepts ### Socket and state The LiveView socket is the fundamental data structure that holds all state in a LiveView. It's an immutable structure containing "assigns" - the data available to your templates. While controllers have `conn`, LiveViews have `socket`. Changes to the socket (via `assign/3` or `update/3`) trigger re-renders. All state is maintained on the server, with only the diffs sent to the client, minimizing network traffic. ### LiveView lifecycle LiveViews have several important lifecycle stages: - [`mount`](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#c:mount/3) - initializes the LiveView with parameters, session data, and socket - [`handle_params`](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#c:handle_params/3) - responds to URL changes and updates LiveView state accordingly - [`handle_event`](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#c:handle_event/3) - responds to user interactions coming from the client - [`handle_info`](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#c:handle_info/2) - responds to regular process messages ### DOM Bindings LiveView provides DOM bindings for convenient client-server interaction: ```html
...
``` These bindings automatically send events to the server when the specified browser events occur, which are then handled in `handle_event/3`. ## Getting Started Phoenix includes code generators for LiveView. Try: ``` $ mix phx.gen.live Blog Post posts title:string body:text ``` This generates a complete LiveView CRUD implementation, similar to `mix phx.gen.html`. To learn more about LiveView, please refer to the [Phoenix LiveView documentation](https://hexdocs.pm/phoenix_live_view). ================================================ FILE: guides/plug.md ================================================ # Plug > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [Request life-cycle guide](request_lifecycle.html). Plug lives at the heart of Phoenix's HTTP layer, and Phoenix puts Plug front and center. We interact with plugs at every step of the request life-cycle, and the core Phoenix components like endpoints, routers, and controllers are all just plugs internally. Let's jump in and find out just what makes Plug so special. [Plug](https://github.com/elixir-lang/plug) is a specification for composable modules in between web applications. It is also an abstraction layer for connection adapters of different web servers. The basic idea of Plug is to unify the concept of a "connection" that we operate on. This differs from other HTTP middleware layers such as Rack, where the request and response are separated in the middleware stack. At the simplest level, the Plug specification comes in two flavors: *function plugs* and *module plugs*. ## Function plugs In order to act as a plug, a function needs to: 1. accept a connection struct (`%Plug.Conn{}`) as its first argument, and connection options as its second one; 2. return a connection struct. Any function that meets these two criteria will do. Here's an example. ```elixir def introspect(conn, _opts) do IO.puts """ Verb: #{inspect(conn.method)} Host: #{inspect(conn.host)} Headers: #{inspect(conn.req_headers)} """ conn end ``` This function does the following: 1. It receives a connection and options (that we do not use) 2. It prints some connection information to the terminal 3. It returns the connection Pretty simple, right? Let's see this function in action by adding it to our endpoint in `lib/hello_web/endpoint.ex`. We can plug it anywhere, so let's do it by inserting `plug :introspect` right before we delegate the request to the router: ```elixir defmodule HelloWeb.Endpoint do ... plug :introspect plug HelloWeb.Router def introspect(conn, _opts) do IO.puts """ Verb: #{inspect(conn.method)} Host: #{inspect(conn.host)} Headers: #{inspect(conn.req_headers)} """ conn end end ``` Function plugs are plugged by passing the function name as an atom. To try the plug out, go back to your browser and fetch [http://localhost:4000](http://localhost:4000). You should see something like this printed in your shell terminal: ```console Verb: "GET" Host: "localhost" Headers: [...] ``` Our plug simply prints information from the connection. Although our initial plug is very simple, you can do virtually anything you want inside of it. To learn about all fields available in the connection and all of the functionality associated to it, see the [documentation for `Plug.Conn`](https://hexdocs.pm/plug/Plug.Conn.html). Now let's look at the other plug variant, the module plugs. ## Module plugs Module plugs are another type of plug that let us define a connection transformation in a module. The module only needs to implement two functions: - [`init/1`] which initializes any arguments or options to be passed to [`call/2`] - [`call/2`] which carries out the connection transformation. [`call/2`] is just a function plug that we saw earlier To see this in action, let's write a module plug that puts the `:locale` key and value into the connection for downstream use in other plugs, controller actions, and our views. Put the contents below in a file named `lib/hello_web/plugs/locale.ex`: ```elixir defmodule HelloWeb.Plugs.Locale do import Plug.Conn @locales ["en", "fr", "de"] def init(default), do: default def call(%Plug.Conn{params: %{"locale" => loc}} = conn, _default) when loc in @locales do assign(conn, :locale, loc) end def call(conn, default) do assign(conn, :locale, default) end end ``` To give it a try, let's add this module plug to our router, by appending `plug HelloWeb.Plugs.Locale, "en"` to our `:browser` pipeline in `lib/hello_web/router.ex`: ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.LayoutView, :root} plug :protect_from_forgery plug :put_secure_browser_headers plug HelloWeb.Plugs.Locale, "en" end ... ``` In the [`init/1`] callback, we pass a default locale to use if none is present in the params. We also use pattern matching to define multiple [`call/2`] function heads to validate the locale in the params, and fall back to `"en"` if there is no match. The [`assign/3`] is a part of the `Plug.Conn` module and it's how we store values in the `conn` data structure. To see the assign in action, go to the template in `lib/hello_web/controllers/page_html/home.html.heex` and add the following code after the closing of the `` tag: ```heex

Locale: {@locale}

``` Go to [http://localhost:4000/](http://localhost:4000/) and you should see the locale exhibited. Visit [http://localhost:4000/?locale=fr](http://localhost:4000/?locale=fr) and you should see the assign changed to `"fr"`. You can use this information alongside [Gettext](https://hexdocs.pm/gettext/Gettext.html) to provide a fully internationalized web application. That's all there is to Plug. Phoenix embraces the plug design of composable transformations all the way up and down the stack. Let's see some examples! ## Where to plug The endpoint, router, and controllers in Phoenix accept plugs. ### Endpoint plugs Endpoints organize all the plugs common to every request, and apply them before dispatching into the router with its custom pipelines. We added a plug to the endpoint like this: ```elixir defmodule HelloWeb.Endpoint do ... plug :introspect plug HelloWeb.Router ``` The default endpoint plugs do quite a lot of work. Here they are in order: - `Plug.Static` - serves static assets. Since this plug comes before the logger, requests for static assets are not logged. - `Phoenix.LiveDashboard.RequestLogger` - sets up the *Request Logger* for Phoenix LiveDashboard, this will allow you to have the option to either pass a query parameter to stream requests logs or to enable/disable a cookie that streams requests logs from your dashboard. - `Plug.RequestId` - generates a unique request ID for each request. - `Plug.Telemetry` - adds instrumentation points so Phoenix can log the request path, status code and request time by default. - `Plug.Parsers` - parses the request body when a known parser is available. By default, this plug can handle URL-encoded, multipart and JSON content (with `Jason`). The request body is left untouched if the request content-type cannot be parsed. - `Plug.MethodOverride` - converts the request method to PUT, PATCH or DELETE for POST requests with a valid `_method` parameter. - `Plug.Head` - converts HEAD requests to GET requests. - `Plug.Session` - a plug that sets up session management. Note that `fetch_session/2` must still be explicitly called before using the session, as this plug just sets up how the session is fetched. In the middle of the endpoint, there is also a conditional block: ```elixir if code_reloading? do socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket plug Phoenix.LiveReloader plug Phoenix.CodeReloader plug Phoenix.Ecto.CheckRepoStatus, otp_app: :hello end ``` This block is only executed in development. It enables: * live reloading - if you change a CSS file, they are updated in-browser without refreshing the page; * [code reloading](`Phoenix.CodeReloader`) - so we can see changes to our application without restarting the server; * check repo status - which makes sure our database is up to date, raising a readable and actionable error otherwise. ### Router plugs In the router, we can declare plugs inside pipelines: ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.LayoutView, :root} plug :protect_from_forgery plug :put_secure_browser_headers plug HelloWeb.Plugs.Locale, "en" end scope "/", HelloWeb do pipe_through :browser get "/", PageController, :index end ``` Routes are defined inside scopes and scopes may pipe through multiple pipelines. Once a route matches, Phoenix invokes all plugs defined in all pipelines associated to that route. For example, accessing "/" will pipe through the `:browser` pipeline, consequently invoking all of its plugs. As we will see in the [routing guide](routing.html), the pipelines themselves are plugs. There, we will also discuss all plugs in the `:browser` pipeline. ### Controller plugs Finally, controllers are plugs too, so we can do: ```elixir defmodule HelloWeb.PageController do use HelloWeb, :controller plug HelloWeb.Plugs.Locale, "en" ``` In particular, controller plugs provide a feature that allows us to execute plugs only within certain actions. For example, you can do: ```elixir defmodule HelloWeb.PageController do use HelloWeb, :controller plug HelloWeb.Plugs.Locale, "en" when action in [:index] ``` And the plug will only be executed for the `index` action. ## Plugs as composition By abiding by the plug contract, we turn an application request into a series of explicit transformations. It doesn't stop there. To really see how effective Plug's design is, let's imagine a scenario where we need to check a series of conditions and then either redirect or halt if a condition fails. Without plug, we would end up with something like this: ```elixir defmodule HelloWeb.MessageController do use HelloWeb, :controller def show(conn, params) do case Authenticator.find_user(conn) do {:ok, user} -> case find_message(params["id"]) do nil -> conn |> put_flash(:info, "That message wasn't found") |> redirect(to: ~p"/") message -> if Authorizer.can_access?(user, message) do render(conn, :show, page: message) else conn |> put_flash(:info, "You can't access that page") |> redirect(to: ~p"/") end end :error -> conn |> put_flash(:info, "You must be logged in") |> redirect(to: ~p"/") end end end ``` Notice how just a few steps of authentication and authorization require complicated nesting and duplication? Let's improve this with a couple of plugs. ```elixir defmodule HelloWeb.MessageController do use HelloWeb, :controller plug :authenticate plug :fetch_message plug :authorize_message def show(conn, params) do render(conn, :show, page: conn.assigns[:message]) end defp authenticate(conn, _) do case Authenticator.find_user(conn) do {:ok, user} -> assign(conn, :user, user) :error -> conn |> put_flash(:info, "You must be logged in") |> redirect(to: ~p"/") |> halt() end end defp fetch_message(conn, _) do case find_message(conn.params["id"]) do nil -> conn |> put_flash(:info, "That message wasn't found") |> redirect(to: ~p"/") |> halt() message -> assign(conn, :message, message) end end defp authorize_message(conn, _) do if Authorizer.can_access?(conn.assigns[:user], conn.assigns[:message]) do conn else conn |> put_flash(:info, "You can't access that page") |> redirect(to: ~p"/") |> halt() end end end ``` To make this all work, we converted the nested blocks of code and used `halt(conn)` whenever we reached a failure path. The `halt(conn)` functionality is essential here: it tells Plug that the next plug should not be invoked. At the end of the day, by replacing the nested blocks of code with a flattened series of plug transformations, we are able to achieve the same functionality in a much more composable, clear, and reusable way. To learn more about plugs, see the documentation for the [Plug project](`Plug`), which provides many built-in plugs and functionalities. [`init/1`]: `c:Plug.init/1` [`call/2`]: `c:Plug.call/2` [`assign/3`]: `Plug.Conn.assign/3` ================================================ FILE: guides/real_time/channels.md ================================================ # Channels > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). Channels are an exciting part of Phoenix that enable soft real-time communication with and between millions of connected clients. Some possible use cases include: - Chat rooms and APIs for messaging apps - Breaking news, like "a goal was scored" or "an earthquake is coming" - Tracking trains, trucks, or race participants on a map - Events in multiplayer games - Monitoring sensors and controlling lights - Notifying a browser that a page's CSS or JavaScript has changed (this is handy in development) Conceptually, Channels are pretty simple. First, clients connect to the server using some transport, like WebSocket. Once connected, they join one or more topics. For example, to interact with a public chat room clients may join a topic called `public_chat`, and to receive updates from a product with ID 7, they may need to join a topic called `product_updates:7`. Clients can push messages to the topics they've joined, and can also receive messages from them. The other way around, Channel servers receive messages from their connected clients, and can push messages to them too. Servers are able to broadcast messages to all clients subscribed to a certain topic. This is illustrated in the following diagram: ```plaintext +----------------+ +--Topic X-->| Mobile Client | | +----------------+ +-------------------+ | +----------------+ | | | +----------------+ | Browser Client |--Topic X-->| Phoenix Server(s) |--+--Topic X-->| Desktop Client | +----------------+ | | | +----------------+ +-------------------+ | | +----------------+ +--Topic X-->| IoT Client | +----------------+ ``` Broadcasts work even if the application runs on several nodes/computers. That is, if two clients have their socket connected to different application nodes and are subscribed to the same topic `T`, both of them will receive messages broadcasted to `T`. That is possible thanks to an internal PubSub mechanism. Channels can support any kind of client: a browser, native app, smart watch, embedded device, or anything else that can connect to a network. All the client needs is a suitable library; see the [Client Libraries](#client-libraries) section below. Each client library communicates using one of the "transports" that Channels understand. Currently, that's either Websockets or long polling, but other transports may be added in the future. Unlike stateless HTTP connections, Channels support long-lived connections, each backed by a lightweight Erlang VM process, working in parallel and maintaining its own state. This architecture scales well; Phoenix Channels [can support millions of subscribers with reasonable latency on a single box](https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections), passing hundreds of thousands of messages per second. And that capacity can be multiplied by adding more nodes to the cluster. ## The Moving Parts Although Channels are simple to use from a client perspective, there are a number of components involved in routing messages to clients across a cluster of servers. Let's take a look at them. ### Overview To start communicating, a client connects to a node (a Phoenix server) using a transport (e.g., Websockets or long polling) and joins one or more channels using that single network connection. One channel server lightweight process is created per client, per topic. Each channel holds onto the `%Phoenix.Socket{}` and can maintain any state it needs within its `socket.assigns`. Once the connection is established, each incoming message from a client is routed, based on its topic, to the correct channel server. If the channel server asks to broadcast a message, that message is sent to the local PubSub, which sends it out to any clients connected to the same server and subscribed to that topic. If there are other nodes in the cluster, the local PubSub also forwards the message to their PubSubs, which send it out to their own subscribers. Because only one message has to be sent per additional node, the performance cost of adding nodes is negligible, while each new node supports many more subscribers. The message flow looks something like this: ```plaintext Channel +-------------------------+ +--------+ route | Sending Client, Topic 1 | | Local | +----------->| Channel.Server |----->| PubSub |--+ +----------------+ | +-------------------------+ +--------+ | | Sending Client |-Transport--+ | | +----------------+ +-------------------------+ | | | Sending Client, Topic 2 | | | | Channel.Server | | | +-------------------------+ | | | | +-------------------------+ | | +----------------+ | Browser Client, Topic 1 | | | | Browser Client |<-------Transport--------| Channel.Server |<----------+ | +----------------+ +-------------------------+ | | | | +-------------------------+ | +----------------+ | Phone Client, Topic 1 | | | Phone Client |<-------Transport--------| Channel.Server |<-+ | +----------------+ +-------------------------+ | +--------+ | | | Remote | | +-------------------------+ +---| PubSub |<-+ +----------------+ | Watch Client, Topic 1 | | +--------+ | | Watch Client |<-------Transport--------| Channel.Server |<-+ | +----------------+ +-------------------------+ | | | +-------------------------+ +--------+ | +----------------+ | IoT Client, Topic 1 | | Remote | | | IoT Client |<-------Transport--------| Channel.Server |<-----| PubSub |<-+ +----------------+ +-------------------------+ +--------+ ``` ### Endpoint In your Phoenix app's `Endpoint` module, a `socket` declaration specifies which socket handler will receive connections on a given URL. ```elixir socket "/socket", HelloWeb.UserSocket, websocket: true, longpoll: false, auth_token: true ``` Phoenix comes with two default transports: websocket and longpoll. You can configure them directly via the `socket` declaration. ### Socket Handlers On the client side, you will establish a socket connection to the route above: ```javascript let socket = new Socket("/socket", {authToken: window.userToken}) ``` On the server, Phoenix will invoke `HelloWeb.UserSocket.connect/2`, passing your parameters and the initial socket state. Within the socket, you can authenticate and identify a socket connection and set default socket assigns. The socket is also where you define your channel routes. ### Channel Routes Channel routes match on the topic string and dispatch matching requests to the given Channel module. The star character `*` acts as a wildcard matcher, so in the following example route, requests for `room:lobby` and `room:123` would both be dispatched to the `RoomChannel`. In your `UserSocket`, you would have: ```elixir channel "room:*", HelloWeb.RoomChannel ``` ### Channels Channels handle events from clients, so they are similar to Controllers, but there are two key differences. Channel events can go both directions - incoming and outgoing. Channel connections also persist beyond a single request/response cycle. Channels are the highest level abstraction for real-time communication components in Phoenix. Each Channel will implement one or more clauses of each of these four callback functions - `join/3`, `terminate/2`, `handle_in/3`, and `handle_out/3`. ### Topics Topics are string identifiers - names that the various layers use in order to make sure messages end up in the right place. As we saw above, topics can use wildcards. This allows for a useful `"topic:subtopic"` convention. Often, you'll compose topics using record IDs from your application layer, such as `"users:123"`. ### Messages The `Phoenix.Socket.Message` module defines a struct with the following keys which denotes a valid message. From the [Phoenix.Socket.Message docs](https://hexdocs.pm/phoenix/Phoenix.Socket.Message.html). - `topic` - The string topic or `"topic:subtopic"` pair namespace, such as `"messages"` or `"messages:123"` - `event` - The string event name, for example `"phx_join"` - `payload` - The message payload - `ref` - The unique string ref ### PubSub PubSub is provided by the `Phoenix.PubSub` module. Interested parties can receive events by subscribing to topics. Other processes can broadcast events to certain topics. This is useful to broadcast messages on channel and also for application development in general. For instance, letting all connected [live views](https://github.com/phoenixframework/phoenix_live_view) to know that a new comment has been added to a post. The PubSub system takes care of getting messages from one node to another so that they can be sent to all subscribers across the cluster. By default, this is done using [Phoenix.PubSub.PG2](https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.PG2.html), which uses native Erlang VM messaging. If your deployment environment does not support distributed Elixir or direct communication between servers, Phoenix also ships with a [Redis Adapter](https://hexdocs.pm/phoenix_pubsub_redis/Phoenix.PubSub.Redis.html) that uses Redis to exchange PubSub data. Please see the [Phoenix.PubSub docs](https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html) for more information. ### Client Libraries Any networked device can connect to Phoenix Channels as long as it has a client library. The following libraries exist today, and new ones are always welcome; to write your own, see our how-to guide [Writing a Channels Client](writing_a_channels_client.md). #### Official Phoenix ships with a JavaScript client that is available when generating a new Phoenix project. The documentation for the JavaScript module is available at [https://hexdocs.pm/phoenix/js/](https://hexdocs.pm/phoenix/js/); the code is in [multiple js files](https://github.com/phoenixframework/phoenix/blob/main/assets/js/phoenix/). #### 3rd Party + Swift (iOS) - [SwiftPhoenix](https://github.com/davidstump/SwiftPhoenixClient) + Java (Android) - [JavaPhoenixChannels](https://github.com/eoinsha/JavaPhoenixChannels) + Kotlin (Android) - [JavaPhoenixClient](https://github.com/dsrees/JavaPhoenixClient) + C# - [PhoenixSharp](https://github.com/Mazyod/PhoenixSharp) + Elixir - [phoenix_gen_socket_client](https://github.com/Aircloak/phoenix_gen_socket_client) - [slipstream](https://hexdocs.pm/slipstream/Slipstream.html) + GDScript (Godot Game Engine) - [GodotPhoenixChannels](https://github.com/alfredbaudisch/GodotPhoenixChannels) ## Tying it all together Let's tie all these ideas together by building a simple chat application. Make sure [you created a new Phoenix application](https://hexdocs.pm/phoenix/up_and_running.html) and now we are ready to generate the `UserSocket`. ### Generating a socket Let's invoke the socket generator to get started: ```console $ mix phx.gen.socket User ``` It will create two files, the client code in `assets/js/user_socket.js` and the server counter-part in `lib/hello_web/channels/user_socket.ex`. After running, the generator will also ask to add the following line to `lib/hello_web/endpoint.ex`: ```elixir defmodule HelloWeb.Endpoint do use Phoenix.Endpoint, otp_app: :hello socket "/socket", HelloWeb.UserSocket, websocket: true, longpoll: false ... end ``` The generator also asks us to import the client code, we will do that later. Next, we will configure our socket to ensure messages get routed to the correct channel. To do that, we'll uncomment the `"room:*"` channel definition: ```elixir defmodule HelloWeb.UserSocket do use Phoenix.Socket ## Channels channel "room:*", HelloWeb.RoomChannel ... ``` Now, whenever a client sends a message whose topic starts with `"room:"`, it will be routed to our RoomChannel. Next, we'll define a `HelloWeb.RoomChannel` module to manage our chat room messages. ### Joining Channels The first priority of your channels is to authorize clients to join a given topic. For authorization, we must implement `join/3` in `lib/hello_web/channels/room_channel.ex`. ```elixir defmodule HelloWeb.RoomChannel do use Phoenix.Channel def join("room:lobby", _message, socket) do {:ok, socket} end def join("room:" <> _private_room_id, _params, _socket) do {:error, %{reason: "unauthorized"}} end end ``` For our chat app, we'll allow anyone to join the `"room:lobby"` topic, but any other room will be considered private and special authorization, say from a database, will be required. (We won't worry about private chat rooms for this exercise, but feel free to explore after we finish.) With our channel in place, let's get the client and server talking. The generated `assets/js/user_socket.js` defines a simple client based on the socket implementation that ships with Phoenix. We can use that library to connect to our socket and join our channel, we just need to set our room name to `"room:lobby"` in that file. ```javascript // assets/js/user_socket.js // ... socket.connect() // Now that you are connected, you can join channels with a topic: let channel = socket.channel("room:lobby", {}) channel.join() .receive("ok", resp => { console.log("Joined successfully", resp) }) .receive("error", resp => { console.log("Unable to join", resp) }) export default socket ``` After that, we need to make sure `assets/js/user_socket.js` gets imported into our application JavaScript file. To do that, uncomment this line in `assets/js/app.js`. ```javascript // ... import "./user_socket.js" ``` Save the file and your browser should auto refresh, thanks to the Phoenix live reloader. If everything worked, we should see "Joined successfully" in the browser's JavaScript console. Our client and server are now talking over a persistent connection. Now let's make it useful by enabling chat. In `lib/hello_web/controllers/page_html/home.html.heex`, we'll replace the existing code with a container to hold our chat messages, and an input field to send them: ```heex
``` Now let's add a couple of event listeners to `assets/js/user_socket.js`: ```javascript // ... let channel = socket.channel("room:lobby", {}) let chatInput = document.querySelector("#chat-input") let messagesContainer = document.querySelector("#messages") chatInput.addEventListener("keypress", event => { if(event.key === 'Enter'){ channel.push("new_msg", {body: chatInput.value}) chatInput.value = "" } }) channel.join() .receive("ok", resp => { console.log("Joined successfully", resp) }) .receive("error", resp => { console.log("Unable to join", resp) }) export default socket ``` All we had to do is detect that enter was pressed and then `push` an event over the channel with the message body. We named the event `"new_msg"`. With this in place, let's handle the other piece of a chat application, where we listen for new messages and append them to our messages container. ```javascript // ... let channel = socket.channel("room:lobby", {}) let chatInput = document.querySelector("#chat-input") let messagesContainer = document.querySelector("#messages") chatInput.addEventListener("keypress", event => { if(event.key === 'Enter'){ channel.push("new_msg", {body: chatInput.value}) chatInput.value = "" } }) channel.on("new_msg", payload => { let messageItem = document.createElement("p") messageItem.innerText = `[${Date()}] ${payload.body}` messagesContainer.appendChild(messageItem) }) channel.join() .receive("ok", resp => { console.log("Joined successfully", resp) }) .receive("error", resp => { console.log("Unable to join", resp) }) export default socket ``` We listen for the `"new_msg"` event using `channel.on`, and then append the message body to the DOM. Now let's handle the incoming and outgoing events on the server to complete the picture. ### Incoming Events We handle incoming events with `handle_in/3`. We can pattern match on the event names, like `"new_msg"`, and then grab the payload that the client passed over the channel. For our chat application, we simply need to notify all other `room:lobby` subscribers of the new message with `broadcast!/3`. ```elixir defmodule HelloWeb.RoomChannel do use Phoenix.Channel def join("room:lobby", _message, socket) do {:ok, socket} end def join("room:" <> _private_room_id, _params, _socket) do {:error, %{reason: "unauthorized"}} end def handle_in("new_msg", %{"body" => body}, socket) do broadcast!(socket, "new_msg", %{body: body}) {:noreply, socket} end end ``` `broadcast!/3` will notify all joined clients on this `socket`'s topic and invoke their `handle_out/3` callbacks. `handle_out/3` isn't a required callback, but it allows us to customize and filter broadcasts before they reach each client. By default, `handle_out/3` is implemented for us and simply pushes the message on to the client. Hooking into outgoing events allows for powerful message customization and filtering. Let's see how. ### Intercepting Outgoing Events We won't implement this for our application, but imagine our chat app allowed users to ignore messages about new users joining a room. We could implement that behavior like this, where we explicitly tell Phoenix which outgoing event we want to intercept and then define a `handle_out/3` callback for those events. (Of course, this assumes that we have an `Accounts` context with an `ignoring_user?/2` function, and that we pass a user in via the `assigns` map). It is important to note that the `handle_out/3` callback will be called for every recipient of a message, so more expensive operations like hitting the database should be considered carefully before being included in `handle_out/3`. ```elixir intercept ["user_joined"] def handle_out("user_joined", msg, socket) do if Accounts.ignoring_user?(socket.assigns[:user], msg.user_id) do {:noreply, socket} else push(socket, "user_joined", msg) {:noreply, socket} end end ``` That's all there is to our basic chat app. Fire up multiple browser tabs and you should see your messages being pushed and broadcasted to all windows! ## Using Token Authentication When we connect, we'll often need to authenticate the client. Fortunately, this is a 5-step process with [Phoenix.Token](https://hexdocs.pm/phoenix/Phoenix.Token.html). ### Step 1 - Enable the `auth_token` functionality in the socket Phoenix supports a transport agnostic way to pass an authentication token to the server. To enable this, we need to pass the `:auth_token` option to the socket declaration in our `Endpoint` module. ```elixir defmodule HelloWeb.Endpoint do use Phoenix.Endpoint, otp_app: :hello socket "/socket", HelloWeb.UserSocket, websocket: true, longpoll: false, auth_token: true ... end ``` ### Step 2 - Assign a Token in the Connection Let's say we have an authentication plug in our app called `OurAuth`. When `OurAuth` authenticates a user, it sets a value for the `:current_user` key in `conn.assigns`. Since the `current_user` exists, we can simply assign the user's token in the connection for use in the layout. We can wrap that behavior up in a private function plug, `put_user_token/2`. This could also be put in its own module as well. To make this all work, we just add `OurAuth` and `put_user_token/2` to the browser pipeline. ```elixir pipeline :browser do ... plug OurAuth plug :put_user_token end defp put_user_token(conn, _) do if current_user = conn.assigns[:current_user] do token = Phoenix.Token.sign(conn, "user socket", current_user.id) assign(conn, :user_token, token) else conn end end ``` Now our `conn.assigns` contains the `current_user` and `user_token`. ### Step 3 - Pass the Token to the JavaScript Next, we need to pass this token to JavaScript. We can do so inside a script tag in `lib/hello_web/components/layouts/root.html.heex` right above the app.js script, as follows: ```heex ``` ### Step 4 - Pass the Token to the Socket Constructor and Verify We also need to pass the `:auth_token` to the socket constructor and verify the user token in the `connect/3` function. To do so, edit `lib/hello_web/channels/user_socket.ex`, as follows: ```elixir def connect(_params_, socket, connect_info) do # max_age: 1209600 is equivalent to two weeks in seconds case Phoenix.Token.verify(socket, "user socket", connect_info[:auth_token], max_age: 1209600) do {:ok, user_id} -> {:ok, assign(socket, :current_user, user_id)} {:error, reason} -> :error end end ``` In our JavaScript, we can use the token set previously when constructing the Socket: ```javascript let socket = new Socket("/socket", {authToken: window.userToken}) ``` We used `Phoenix.Token.verify/4` to verify the user token provided by the client. `Phoenix.Token.verify/4` returns either `{:ok, user_id}` or `{:error, reason}`. We can pattern match on that return in a `case` statement. With a verified token, we set the user's id as the value to `:current_user` in the socket. Otherwise, we return `:error`. ### Step 5 - Connect to the socket in JavaScript With authentication set up, we can connect to sockets and channels from JavaScript. ```javascript let socket = new Socket("/socket", {authToken: window.userToken}) socket.connect() ``` Now that we are connected, we can join channels with a topic: ```javascript let channel = socket.channel("topic:subtopic", {}) channel.join() .receive("ok", resp => { console.log("Joined successfully", resp) }) .receive("error", resp => { console.log("Unable to join", resp) }) export default socket ``` Note that token authentication is preferable since it's transport agnostic and well-suited for long running-connections like channels, as opposed to using sessions or other authentication approaches. ## Fault Tolerance and Reliability Guarantees Servers restart, networks split, and clients lose connectivity. In order to design robust systems, we need to understand how Phoenix responds to these events and what guarantees it offers. ### Handling Reconnection Clients subscribe to topics, and Phoenix stores those subscriptions in an in-memory ETS table. If a channel crashes, the clients will need to reconnect to the topics they had previously subscribed to. Fortunately, the Phoenix JavaScript client knows how to do this. The server will notify all the clients of the crash. This will trigger each client's `Channel.onError` callback. The clients will attempt to reconnect to the server using an exponential backoff strategy. Once they reconnect, they'll attempt to rejoin the topics they had previously subscribed to. If they are successful, they'll start receiving messages from those topics as before. ### Resending Client Messages Channel clients queue outgoing messages into a `PushBuffer`, and send them to the server when there is a connection. If no connection is available, the client holds on to the messages until it can establish a new connection. With no connection, the client will hold the messages in memory until it establishes a connection, or until it receives a `timeout` event. The default timeout is set to 5000 milliseconds. The client won't persist the messages in the browser's local storage, so if the browser tab closes, the messages will be gone. ### Resending Server Messages Phoenix uses an at-most-once strategy when sending messages to clients. If the client is offline and misses the message, Phoenix won't resend it. Phoenix doesn't persist messages on the server. If the server restarts, unsent messages will be gone. If our application needs stronger guarantees around message delivery, we'll need to write that code ourselves. Common approaches involve persisting messages on the server and having clients request missing messages. For example, you can track a `last_seen_id` (or `last_updated_at`) on the client. On join, the client will pass the `last_seen_id` via the channel params for the last thing it saw, which lets the server know how to catch the client up with side effects that have happened since that id. On the client, anytime an event is received for a "new_message", the client bumps its `last_seen_id` so that it can recover gracefully across disconnect/reconnect. The code might look something like this: ```javascript // on the client let socket = new Socket(...) let lastSeenMsg = {} let roomParams = () => lastSeenMsg.id ? {last_seen_id: lastSeenMsg.id} : {} let roomChannel = socket.channel("rooms:123", roomParams) roomChannel.on("new_message", msg => { lastSeenMsg = msg renderNewMessage(msg) }) roomChannel.join().receive("ok", ({messages}) => { lastSeenMsg = messages[messages.length - 1] renderMessages(messages) }) ``` ```elixir # room_channel.ex on the server def join("rooms:" <> id, params, socket) do ... messages = fetch_messages_since(params["last_seen_id"]) {:ok, %{messages: messages}, socket} end ``` ## Example Application To see an example of the application we just built, checkout the project [phoenix_chat_example](https://github.com/chrismccord/phoenix_chat_example). ================================================ FILE: guides/real_time/presence.md ================================================ # Presence > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [Channels guide](channels.html). Phoenix Presence is a feature which allows you to register process information on a topic and replicate it transparently across a cluster. It's a combination of both a server-side and client-side library, which makes it simple to implement. A simple use-case would be showing which users are currently online in an application. Phoenix Presence is special for a number of reasons. It has no single point of failure, no single source of truth, relies entirely on the standard library with no operational dependencies and self-heals. ## Setting up We are going to use Presence to track which users are connected on the server and send updates to the client as users join and leave. We will deliver those updates via Phoenix Channels. Therefore, let's create a `RoomChannel`, as we did in the channels guides: ```console $ mix phx.gen.channel Room ``` Follow the steps after the generator and you are ready to start tracking presence. ## The Presence generator To get started with Presence, we'll first need to generate a presence module. We can do this with the `mix phx.gen.presence` task: ```console $ mix phx.gen.presence * creating lib/hello_web/channels/presence.ex Add your new module to your supervision tree, in lib/hello/application.ex: children = [ ... HelloWeb.Presence, ] You're all set! See the Phoenix.Presence docs for more details: https://hexdocs.pm/phoenix/Phoenix.Presence.html ``` If we open up the `lib/hello_web/channels/presence.ex` file, we will see the following line: ```elixir use Phoenix.Presence, otp_app: :hello, pubsub_server: Hello.PubSub ``` This sets up the module for presence, defining the functions we require for tracking presences. As mentioned in the generator task, we should add this module to our supervision tree in `application.ex`: ```elixir children = [ ... HelloWeb.Presence, ] ``` ## Usage With Channels and JavaScript Next, we will create the channel that we'll communicate presence over. After a user joins, we can push the list of presences down the channel and then track the connection. We can also provide a map of additional information to track. ```elixir defmodule HelloWeb.RoomChannel do use Phoenix.Channel alias HelloWeb.Presence def join("room:lobby", %{"name" => name}, socket) do send(self(), :after_join) {:ok, assign(socket, :name, name)} end def handle_info(:after_join, socket) do {:ok, _} = Presence.track(socket, socket.assigns.name, %{ online_at: inspect(System.system_time(:second)) }) push(socket, "presence_state", Presence.list(socket)) {:noreply, socket} end end ``` Finally, we can use the client-side Presence library included in `phoenix.js` to manage the state and presence diffs that come down the socket. It listens for the `"presence_state"` and `"presence_diff"` events and provides a simple callback for you to handle the events as they happen, with the `onSync` callback. The `onSync` callback allows you to easily react to presence state changes, which most often results in re-rendering an updated list of active users. You can use the `list` method to format and return each individual presence based on the needs of your application. To iterate users, we use the `presences.list()` function which accepts a callback. The callback will be called for each presence item with 2 arguments, the presence id and a list of metas (one for each presence for that presence id). We use this to display the users and the number of devices they are online with. We can see presence working by adding the following to `assets/js/app.js`: ```javascript import {Socket, Presence} from "phoenix" let socket = new Socket("/socket", {authToken: window.userToken}) let channel = socket.channel("room:lobby", {name: window.location.search.split("=")[1]}) let presence = new Presence(channel) function renderOnlineUsers(presence) { let response = "" presence.list((id, {metas: [first, ...rest]}) => { let count = rest.length + 1 response += `
${id} (count: ${count})
` }) document.querySelector("main").innerHTML = response } socket.connect() presence.onSync(() => renderOnlineUsers(presence)) channel.join() ``` We can ensure this is working by opening 3 browser tabs. If we navigate to on two browser tabs and then we should see: ```plaintext Alice (count: 2) Bob (count: 1) ``` If we close one of the Alice tabs, then the count should decrease to 1. If we close another tab, the user should disappear from the list entirely. ### Making it safe In our initial implementation, we are passing the name of the user as part of the URL. However, in many systems, you want to allow only logged in users to access the presence functionality. To do so, you should set up token authentication, [as detailed in the token authentication section of the channels guide](channels.html#using-token-authentication). With token authentication, you should access `socket.assigns.user_id`, set in `UserSocket`, instead of `socket.assigns.name` set from parameters. ## Usage With LiveView Whilst Phoenix does ship with a JavaScript API for dealing with presence, it is also possible to extend the `HelloWeb.Presence` module to support [LiveView](https://hexdocs.pm/phoenix_live_view). One thing to keep in mind when dealing with LiveView, is that each LiveView is a stateful process, so if we keep the presence state in the LiveView, each LiveView process will contain the full list of online users in memory. Instead, we can keep track of the online users within the `Presence` process, and pass separate events to the LiveView, which can use a stream to update the online list. To start with, we need to update the `lib/hello_web/channels/presence.ex` file to add some optional callbacks to the `HelloWeb.Presence` module. Firstly, we add the `init/1` callback. This allows us to keep track of the presence state within the process. ```elixir def init(_opts) do {:ok, %{}} end ``` The presence module also allows a `fetch/2` callback, this allows the data fetched from the presence to be modified, allowing us to define the shape of the response. In this case we are adding an `id` and a `user` map. ```elixir def fetch(_topic, presences) do for {key, %{metas: [meta | metas]}} <- presences, into: %{} do # user can be populated here from the database here we populate # the name for demonstration purposes {key, %{metas: [meta | metas], id: meta.id, user: %{name: meta.id}}} end end ``` The final thing to add is the `handle_metas/4` callback. This callback updates the state that we keep track of in `HelloWeb.Presence` based on the user leaves and joins. ```elixir def handle_metas(topic, %{joins: joins, leaves: leaves}, presences, state) do for {user_id, presence} <- joins do user_data = %{id: user_id, user: presence.user, metas: Map.fetch!(presences, user_id)} msg = {__MODULE__, {:join, user_data}} Phoenix.PubSub.local_broadcast(Hello.PubSub, "proxy:#{topic}", msg) end for {user_id, presence} <- leaves do metas = case Map.fetch(presences, user_id) do {:ok, presence_metas} -> presence_metas :error -> [] end user_data = %{id: user_id, user: presence.user, metas: metas} msg = {__MODULE__, {:leave, user_data}} Phoenix.PubSub.local_broadcast(Hello.PubSub, "proxy:#{topic}", msg) end {:ok, state} end ``` You can see that we are broadcasting events for the joins and leaves. These will be listened to by the LiveView process. You'll also see that we use "proxy" channel when broadcasting the joins and leaves. This is because we don't want our LiveView process to receive the presence events directly. We can add a few helper functions so that this particular implementation detail is abstracted from the LiveView module. ```elixir def list_online_users(), do: list("online_users") |> Enum.map(fn {_id, presence} -> presence end) def track_user(name, params), do: track(self(), "online_users", name, params) def subscribe(), do: Phoenix.PubSub.subscribe(Hello.PubSub, "proxy:online_users") ``` Now that we have our presence module set up and broadcasting events, we can create a LiveView. Create a new file `lib/hello_web/live/online/index.ex` with the following contents: ```elixir defmodule HelloWeb.OnlineLive do use HelloWeb, :live_view def mount(params, _session, socket) do socket = stream(socket, :presences, []) socket = if connected?(socket) do HelloWeb.Presence.track_user(params["name"], %{id: params["name"]}) HelloWeb.Presence.subscribe() stream(socket, :presences, HelloWeb.Presence.list_online_users()) else socket end {:ok, socket} end def render(assigns) do ~H"""
  • {id} ({length(metas)})
""" end def handle_info({HelloWeb.Presence, {:join, presence}}, socket) do {:noreply, stream_insert(socket, :presences, presence)} end def handle_info({HelloWeb.Presence, {:leave, presence}}, socket) do if presence.metas == [] do {:noreply, stream_delete(socket, :presences, presence)} else {:noreply, stream_insert(socket, :presences, presence)} end end end ``` If we add this route to the `lib/hello_web/router.ex`: ```elixir live "/online/:name", OnlineLive, :index ``` Then we can navigate to http://localhost:4000/online/Alice in one tab, and http://localhost:4000/online/Bob in another, you'll see that the presences are tracked, along with the number of presences per user. Opening and closing tabs with various users will update the presence list in real-time. ================================================ FILE: guides/request_lifecycle.md ================================================ # Request life-cycle > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). The goal of this guide is to talk about Phoenix's request life-cycle. This guide will take a practical approach where we will learn by doing: we will add two new pages to our Phoenix project and comment on how the pieces fit together along the way. Let's get on with our first new Phoenix page! ## Adding a new page When your browser accesses [http://localhost:4000/](http://localhost:4000/), it sends an HTTP request to whatever service is running on that address, in this case our Phoenix application. The HTTP request is made of a verb and a path. For example, the following browser requests translate into: | Browser address bar | Verb | Path | |:------------------------------------|:-----|:--------------| | | GET | / | | | GET | /hello | | | GET | /hello/world | There are other HTTP verbs. For example, submitting a form typically uses the POST verb. Web applications typically handle requests by mapping each verb/path pair onto a specific part of your application. In Phoenix, this mapping is done by the router. For example, we may map "/articles" to a portion of our application that shows all articles. Therefore, to add a new page, our first task is to add a new route. ### A new route The router maps unique HTTP verb/path pairs to controller/action pairs which will handle them. Controllers in Phoenix are simply Elixir modules. Actions are functions that are defined within these controllers. Phoenix generates a router file for us in new applications at `lib/hello_web/router.ex`. This is where we will be working for this section. The route for our "Welcome to Phoenix!" page from the previous [Up And Running Guide](up_and_running.html) looks like this: ```elixir get "/", PageController, :home ``` Let's digest what this route is telling us. Visiting [http://localhost:4000/](http://localhost:4000/) issues an HTTP `GET` request to the root path. All requests like this will be handled by the `home/2` function in the `HelloWeb.PageController` module defined in `lib/hello_web/controllers/page_controller.ex`. The page we are going to build will say "Hello World, from Phoenix!" when we point our browser to [http://localhost:4000/hello](http://localhost:4000/hello). The first thing we need to do is to create the page route for a new page. Let's open up `lib/hello_web/router.ex` in a text editor. For a brand new application, it looks like this: ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.Layouts, :root} plug :protect_from_forgery plug :put_secure_browser_headers end pipeline :api do plug :accepts, ["json"] end scope "/", HelloWeb do pipe_through :browser get "/", PageController, :home end # Other scopes may use custom stacks. # scope "/api", HelloWeb do # pipe_through :api # end # ... end ``` For now, we'll ignore the pipelines and the use of `scope` here and just focus on adding a route. We will discuss those in the [Routing guide](routing.html). Let's add a new route to the router that maps a `GET` request for `/hello` to the `index` action of a soon-to-be-created `HelloWeb.HelloController` inside the `scope "/" do` block of the router: ```elixir scope "/", HelloWeb do pipe_through :browser get "/", PageController, :home get "/hello", HelloController, :index end ``` ### A new controller Controllers are Elixir modules, and actions are Elixir functions defined in them. The purpose of actions is to gather the data and perform the tasks needed for rendering. Our route specifies that we need a `HelloWeb.HelloController` module with an `index/2` function. To make the `index` action happen, let's create a new `lib/hello_web/controllers/hello_controller.ex` file, and make it look like the following: ```elixir defmodule HelloWeb.HelloController do use HelloWeb, :controller def index(conn, _params) do render(conn, :index) end end ``` We'll save a discussion of `use HelloWeb, :controller` for the [Controllers guide](controllers.html). For now, let's focus on the `index` action. All controller actions take two arguments. The first is `conn`, a struct which holds a ton of data about the request. The second is `params`, which are the request parameters. Here, we are not using `params`, and we avoid compiler warnings by prefixing it with `_`. The core of this action is `render(conn, :index)`. It tells Phoenix to render the `index` template. The modules responsible for rendering are called views. By default, Phoenix views are named after the controller (`HelloController`) and format (`HTML` in this case), so Phoenix is expecting a `HelloWeb.HelloHTML` module to exist and define an `index/1` function. ### A new view Phoenix views act as the presentation layer. For example, we expect the output of rendering `index` to be a complete HTML page. To make our lives easier, we often use templates for creating those HTML pages. Let's create a new view. Create `lib/hello_web/controllers/hello_html.ex` and make it look like this: ```elixir defmodule HelloWeb.HelloHTML do use HelloWeb, :html end ``` To add templates to this view, we can define them as functions in the module or in separate files. Let's start by defining a function: ```elixir defmodule HelloWeb.HelloHTML do use HelloWeb, :html def index(assigns) do ~H""" Hello! """ end end ``` We defined a function that receives `assigns` as arguments and used [the `~H` sigil](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#sigil_H/2) to specify the content we want to render. Inside the `~H` sigil, we used a templating language called HEEx, which stands for "HTML+EEx". `EEx` is a library for embedding Elixir that ships as part of Elixir itself. "HTML+EEx" is a Phoenix extension of EEx that is HTML aware, with support for HTML validation, components, and automatic escaping of values. The latter protects you from security vulnerabilities like Cross-Site Scripting with no extra work on your part. We say that any function that receives `assigns` and returns templates to be a **function component**. A template file works in the same way. Let's give it a try by defining a template in its own file. First, delete our `def index(assigns)` function from above and replace it with an `embed_templates` declaration: ```elixir defmodule HelloWeb.HelloHTML do use HelloWeb, :html embed_templates "hello_html/*" end ``` Here we are saying we want to embed all `.heex` templates found in the sibling `hello_html` directory into our module as function components. Next, we need to add files to the `lib/hello_web/controllers/hello_html` directory. A template file has the following structure: `NAME.FORMAT.TEMPLATING_LANGUAGE`. In our case, let's create an `index.html.heex` file at `lib/hello_web/controllers/hello_html/index.html.heex`: ```heex

Hello World, from Phoenix!

``` Phoenix will see the template file and compile it into an `index(assigns)` function, similar as before. There is no runtime or performance difference between the two styles. Also note the controller name (`HelloController`) and the view name (`HelloHTML`) and their respective files, `hello_controller.ex` and `hello_html.ex` all follow the same naming convention, and are named after each other. You could name the directory anything you want, as long as you update the `embed_templates` setting accordingly, but it's best to follow conventions. ```console lib/hello_web ├── controllers │ ├── hello_controller.ex │ ├── hello_html.ex │ ├── hello_html | ├── index.html.heex (NEW FILE!) ``` Now that we've got the route, controller, view, and template, we should be able to point our browser at [http://localhost:4000/hello](http://localhost:4000/hello) and see our greeting from Phoenix! Phoenix Greets Us In case you stopped the server along the way, the task to restart it is `mix phx.server`. If you didn't stop it, everything should update on the fly: Phoenix has hot code reloading! ## Layouts Even though our `index.html.heex` file consists of only a single `section` tag, the page we get is a full HTML document. Our index template is actually rendered into a separate layout: `lib/hello_web/components/layouts/root.html.heex`, which contains the basic HTML skeleton of the page. If you open this file, you'll see a line that looks like this at the bottom: ```heex {@inner_content} ``` This line injects our template into the layout before the HTML is sent off to the browser. The root layout, as the name implies, is a barebone layout with mostly the `` tag and a structure that is shared across **all of your pages**. Richer features, such as sidebar, menus, etc. are part of your application layout, which we will explore in a couple sections below. ## From endpoint to views Having built our first page, we're beginning to understand how the request life-cycle is put together. Now let's take a more holistic look at it. All HTTP requests start in our application endpoint. You can find it as a module named `HelloWeb.Endpoint` in `lib/hello_web/endpoint.ex`. Once you open up the endpoint file, you will see that, similar to the router, the endpoint has many calls to `plug`. `Plug` is a library and a specification for stitching web applications together. It is an essential part of how Phoenix handles requests and we will discuss it in detail in the [Plug guide](plug.html) coming next. For now, it suffices to say that each plug defines a slice of request processing. In the endpoint you will find a skeleton roughly like this: ```elixir defmodule HelloWeb.Endpoint do use Phoenix.Endpoint, otp_app: :hello plug Plug.Static, ... plug Plug.RequestId plug Plug.Telemetry, ... plug Plug.Parsers, ... plug Plug.MethodOverride plug Plug.Head plug Plug.Session, ... plug HelloWeb.Router end ``` Each of these plugs have a specific responsibility that we will learn later. The last plug is precisely the `HelloWeb.Router` module. This allows the endpoint to delegate all further request processing to the router. As we now know, its main responsibility is to map verb/path pairs to controllers. The controller then tells a view to render a template. At this moment, you may be thinking this can be a lot of steps to simply render a page. However, as our application grows in complexity, we will see that each layer serves a distinct purpose: * endpoint (`Phoenix.Endpoint`) - the endpoint contains the common and initial path that all requests go through. If you want something to happen on all requests, it goes in the endpoint. * router (`Phoenix.Router`) - the router is responsible for dispatching verb/path pairs to controllers. The router also allows us to scope functionality. For example, some pages in your application may require user authentication, others may not. * controller (`Phoenix.Controller`) - the job of the controller is to retrieve request information, talk to your business domain, and prepare data for the presentation layer. * view - the view handles the structured data from the controller and converts it to a presentation to be shown to users. Views are often named after the content format they are rendering. Let's do a quick recap on how the last three components work together by adding another page. This time, we will use some additional features, such as layout components and content interpolation. ## Another new page Let's add just a little complexity to our application. We're going to add a new page that will recognize a piece of the URL, label it as a "messenger" and pass it through the controller into the template so our messenger can say hello. As we did last time, the first thing we'll do is create a new route. ### Another new route For this exercise, we're going to reuse `HelloController` created at the [previous step](request_lifecycle.html#a-new-controller) and add a new `show` action. We'll add a line just below our last route, like this: ```elixir scope "/", HelloWeb do pipe_through :browser get "/", PageController, :home get "/hello", HelloController, :index get "/hello/:messenger", HelloController, :show end ``` Notice that we use the `:messenger` syntax in the path. Phoenix will take whatever value that appears in that position in the URL and convert it into a parameter. For example, if we point the browser at: `http://localhost:4000/hello/Frank`, the value of `"messenger"` will be `"Frank"`. ### Another new action Requests to our new route will be handled by the `HelloWeb.HelloController` `show` action. We already have the controller at `lib/hello_web/controllers/hello_controller.ex`, so all we need to do is edit that controller and add a `show` action to it. This time, we'll need to extract the messenger from the parameters so that we can pass it (the messenger) to the template. To do that, we add this show function to the controller: ```elixir def show(conn, %{"messenger" => messenger}) do render(conn, :show, messenger: messenger) end ``` Within the body of the `show` action, we also pass a third argument to the render function, a key-value pair where `:messenger` is the key, and the `messenger` variable is passed as the value. If the body of the action needs access to the full map of parameters bound to the `params` variable, in addition to the bound messenger variable, we could define `show/2` like this: ```elixir def show(conn, %{"messenger" => messenger} = params) do ... end ``` It's good to remember that the keys of the `params` map will always be strings, and that the equals sign does not represent assignment, but is instead a [pattern match](https://hexdocs.pm/elixir/pattern-matching.html) assertion. ### Another new template For the last piece of this puzzle, we'll need a new template. Since it is for the `show` action of `HelloController`, it will go into the `lib/hello_web/controllers/hello_html` directory and be called `show.html.heex`. It will look surprisingly like our `index.html.heex` template, except that we will need to display the name of our messenger. Let's write the new template down and then explain what it does: ```heex

Hello World, from {@messenger}!

 ``` If you point your browser to [http://localhost:4000/hello/Frank](http://localhost:4000/hello/Frank), you should see a page that looks like this: Frank Greets Us from Phoenix Let's break what the template does into parts. This template has the `.heex` extension which stands for HTML + Embedded Elixir. There are three features from HEEx we are using in the template above: * Assigns, such as `@messenger` and `@flash` - values we pass to the view from the controller are collectively called our "assigns". We could access our messenger value via `assigns.messenger` and `assigns.flash`, but Phoenix gives us the much cleaner `@` syntax for use in templates. * Content interpolation, such as `{@messenger}` - any Elixir code that goes between `{...}` will be executed, and the resulting value will replace the tag in the HTML output * Function component tags, as in `` - the reason templates are called function components is because we can compose them! In this case, there is an `HelloWeb.Layouts.app` function, that defines our application layout, which we invoke with our custom content Also note how these three features compose: we are passing the `@flash` assign as an Elixir value to the `` component. As we will learn later, flash messages are used to display temporary messages to the user, such as success or error messages. We will learn more about them in the [Components and HEEx templates](components.html) guide. We are done! Feel free to play around a bit. Whatever you put after `/hello/` will appear on the page as your messenger. ================================================ FILE: guides/routing.md ================================================ # Routing > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [Request life-cycle guide](request_lifecycle.html). Routers are the main hubs of Phoenix applications. They match HTTP requests to controller actions, wire up real-time channel handlers, and define a series of pipeline transformations scoped to a set of routes. The router file that Phoenix generates, `lib/hello_web/router.ex`, will look something like this one: ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.Layouts, :root} plug :protect_from_forgery plug :put_secure_browser_headers end pipeline :api do plug :accepts, ["json"] end scope "/", HelloWeb do pipe_through :browser get "/", PageController, :home end # Other scopes may use custom stacks. # scope "/api", HelloWeb do # pipe_through :api # end # ... end ``` Both the router and controller module names will be prefixed with the name you gave your application suffixed with `Web`. The first line of this module, `use HelloWeb, :router`, simply makes Phoenix router functions available in our particular router. Scopes have their own section in this guide, so we won't spend time on the `scope "/", HelloWeb do` block here. The `pipe_through :browser` line will get a full treatment in the "Pipelines" section of this guide. For now, you only need to know that pipelines allow a set of plugs to be applied to different sets of routes. Inside the scope block, however, we have our first actual route: ```elixir get "/", PageController, :home ``` `get` is a Phoenix macro that corresponds to the HTTP verb GET. Similar macros exist for other HTTP verbs, including POST, PUT, PATCH, DELETE, OPTIONS, CONNECT, TRACE, and HEAD. > #### Why the macros? {: .info} > > Phoenix does its best to keep the usage of macros low. You may have noticed, however, that the `Phoenix.Router` relies heavily on macros. Why is that? > > We use `get`, `post`, `put`, and `delete` to define your routes. We use macros for two purposes: > > * They define the routing engine, used on every request, to choose which controller to dispatch the request to. Thanks to macros, Phoenix compiles all of your routes to a huge case-statement with pattern matching rules, which is heavily optimized by the Erlang VM > > * For each route you define, we also define metadata to implement `Phoenix.VerifiedRoutes`. As we will soon learn, verified routes allow us to reference any route as if it were a plain looking string, except that it is verified by the compiler to be valid (making it much harder to ship broken links, forms, mails, etc to production) > > In other words, the router relies on macros to build applications that are faster and safer. Also remember that macros in Elixir are compile-time only, which gives plenty of stability after the code is compiled. As we will learn next, Phoenix also provides introspection for all defined routes via `mix phx.routes`. ## Examining routes Phoenix provides an excellent tool for investigating routes in an application: `mix phx.routes`. Let's see how this works. Go to the root of a newly-generated Phoenix application and run `mix phx.routes`. You should see something like the following, generated with all routes you currently have: ```console $ mix phx.routes GET / HelloWeb.PageController :home ... ``` The route above tells us that any HTTP GET request for the root of the application will be handled by the `home` action of the `HelloWeb.PageController`. ## Resources The router supports other macros besides those for HTTP verbs like [`get`](`Phoenix.Router.get/3`), [`post`](`Phoenix.Router.post/3`), and [`put`](`Phoenix.Router.put/3`). The most important among them is [`resources`](`Phoenix.Router.resources/4`). Let's add a resource to our `lib/hello_web/router.ex` file like this: ```elixir scope "/", HelloWeb do pipe_through :browser get "/", PageController, :home resources "/users", UserController ... end ``` For now it doesn't matter that we don't actually have a `HelloWeb.UserController`. Run `mix phx.routes` once again at the root of your project. You should see something like the following: ```console ... GET /users HelloWeb.UserController :index GET /users/:id/edit HelloWeb.UserController :edit GET /users/new HelloWeb.UserController :new GET /users/:id HelloWeb.UserController :show POST /users HelloWeb.UserController :create PATCH /users/:id HelloWeb.UserController :update PUT /users/:id HelloWeb.UserController :update DELETE /users/:id HelloWeb.UserController :delete ... ``` This is the standard matrix of HTTP verbs, paths, and controller actions. For a while, this was known as RESTful routes, but most consider this a misnomer nowadays. Let's look at them individually. - A GET request to `/users` will invoke the `index` action to show all the users. - A GET request to `/users/:id/edit` will invoke the `edit` action with an ID to retrieve an individual user from the data store and present the information in a form for editing. - A GET request to `/users/new` will invoke the `new` action to present a form for creating a new user. - A GET request to `/users/:id` will invoke the `show` action with an id to show an individual user identified by that ID. - A POST request to `/users` will invoke the `create` action to save a new user to the data store. - A PATCH request to `/users/:id` will invoke the `update` action with an ID to save the updated user to the data store. - A PUT request to `/users/:id` will also invoke the `update` action with an ID to save the updated user to the data store. - A DELETE request to `/users/:id` will invoke the `delete` action with an ID to remove the individual user from the data store. If we don't need all these routes, we can be selective using the `:only` and `:except` options to filter specific actions. Let's say we have a read-only posts resource. We could define it like this: ```elixir resources "/posts", PostController, only: [:index, :show] ``` Running `mix phx.routes` shows that we now only have the routes to the index and show actions defined. ```console GET /posts HelloWeb.PostController :index GET /posts/:id HelloWeb.PostController :show ``` Similarly, if we have a comments resource, and we don't want to provide a route to delete one, we could define a route like this. ```elixir resources "/comments", CommentController, except: [:delete] ``` Running `mix phx.routes` now shows that we have all the routes except the DELETE request to the delete action. ```console GET /comments HelloWeb.CommentController :index GET /comments/:id/edit HelloWeb.CommentController :edit GET /comments/new HelloWeb.CommentController :new GET /comments/:id HelloWeb.CommentController :show POST /comments HelloWeb.CommentController :create PATCH /comments/:id HelloWeb.CommentController :update PUT /comments/:id HelloWeb.CommentController :update ``` The `Phoenix.Router.resources/4` macro describes additional options for customizing resource routes. ## Verified Routes Phoenix includes `Phoenix.VerifiedRoutes` module which provides compile-time checks of router paths against your router by using the `~p` sigil. For example, you can write paths in controllers, tests, and templates and the compiler will make sure those actually match routes defined in your router. Let's see it in action. Run `iex -S mix` at the root of the project. We'll define a throwaway example module that builds a couple `~p` route paths. ```elixir iex> defmodule RouteExample do ...> use HelloWeb, :verified_routes ...> ...> def example do ...> ~p"/comments" ...> ~p"/unknown/123" ...> end ...> end warning: no route path for HelloWeb.Router matches "/unknown/123" iex:5: RouteExample.example/0 {:module, RouteExample, ...} iex> ``` Notice how the first call to an existing route, `~p"/comments"` gave no warning, but a bad route path `~p"/unknown/123"` produced a compiler warning, just as it should. This is significant because it allows us to write otherwise hard-coded paths in our application and the compiler will let us know whenever we write a bad route or change our routing structure. Phoenix projects are set up out of the box to allow use of verified routes throughout your web layer, including tests. For example in your templates you can render `~p` links: ```heex Welcome Page! View Comments ``` Or in a controller, issue a redirect: ```elixir redirect(conn, to: ~p"/comments/#{comment}") ``` Using `~p` for route paths ensures our application paths and URLs stay up to date with the router definitions. The compiler will catch bugs for us, and let us know when we change routes that are referenced elsewhere in our application. ### More on verified routes What about paths with query strings? You can add query string key values directly, as a keyword list or map of values, for example: ```elixir ~p"/users/17?admin=true&active=false" "/users/17?admin=true&active=false" ~p"/users/17?#{[admin: true]}" "/users/17?admin=true" ~p"/users/17?#{%{admin: true}}" "/users/17?admin=true" ``` What if we need a full URL instead of a path? Just wrap your path with a call to `Phoenix.VerifiedRoutes.url/1`, which is imported everywhere that `~p` is available: ```elixir url(~p"/users") "http://localhost:4000/users" ``` The `url` calls will get the host, port, proxy port, and SSL information needed to construct the full URL from the configuration parameters set for each environment. We'll talk about configuration in more detail in its own guide. For now, you can take a look at `config/dev.exs` file in your own project to see those values. ## Nested resources It is also possible to nest resources in a Phoenix router. Let's say we also have a `posts` resource that has a many-to-one relationship with `users`. That is to say, a user can create many posts, and an individual post belongs to only one user. We can represent that by adding a nested route in `lib/hello_web/router.ex` like this: ```elixir resources "/users", UserController do resources "/posts", PostController end ``` When we run `mix phx.routes` now, in addition to the routes we saw for `users` above, we get the following set of routes: ```console ... GET /users/:user_id/posts HelloWeb.PostController :index GET /users/:user_id/posts/:id/edit HelloWeb.PostController :edit GET /users/:user_id/posts/new HelloWeb.PostController :new GET /users/:user_id/posts/:id HelloWeb.PostController :show POST /users/:user_id/posts HelloWeb.PostController :create PATCH /users/:user_id/posts/:id HelloWeb.PostController :update PUT /users/:user_id/posts/:id HelloWeb.PostController :update DELETE /users/:user_id/posts/:id HelloWeb.PostController :delete ... ``` We see that each of these routes scopes the posts to a user ID. For the first one, we will invoke `PostController`'s `index` action, but we will pass in a `user_id`. This implies that we would display all the posts for that individual user only. The same scoping applies for all these routes. When building paths for nested routes, we will need to interpolate the IDs where they belong in route definition. For the following `show` route, `42` is the `user_id`, and `17` is the `post_id`. ```elixir user_id = 42 post_id = 17 ~p"/users/#{user_id}/posts/#{post_id}" "/users/42/posts/17" ``` Verified routes also support the `Phoenix.Param` protocol, but we don't need to concern ourselves with Elixir protocols just yet. Just know that once we start building our application with structs like `%User{}` and `%Post{}`, we'll be able to interpolate those data structures directly into our `~p` paths and Phoenix will pluck out the correct fields to use in the route. ```elixir ~p"/users/#{user}/posts/#{post}" "/users/42/posts/17" ``` Notice how we didn't need to interpolate `user.id` or `post.id`? This is particularly nice if we decide later we want to make our URLs a little nicer and start using slugs instead. We don't need to change any of our `~p`'s! ## Scoped routes Scopes are a way to group routes under a common path prefix and scoped set of plugs. We might want to do this for admin functionality, APIs, and especially for versioned APIs. Let's say we have user-generated reviews on a site, and that those reviews first need to be approved by an administrator. The semantics of these resources are quite different, and they might not share the same controller. Scopes enable us to segregate these routes. The paths to the user-facing reviews would look like a standard resource. ```console /reviews /reviews/1234 /reviews/1234/edit ... ``` The administration review paths can be prefixed with `/admin`. ```console /admin/reviews /admin/reviews/1234 /admin/reviews/1234/edit ... ``` We accomplish this with a scoped route that sets a path option to `/admin` like this one. We can nest this scope inside another scope, but instead, let's set it by itself at the root, by adding to `lib/hello_web/router.ex` the following: ```elixir scope "/admin", HelloWeb.Admin do pipe_through :browser resources "/reviews", ReviewController end ``` We define a new scope where all routes are prefixed with `/admin` and all controllers are under the `HelloWeb.Admin` namespace. Running `mix phx.routes` again, in addition to the previous set of routes we get the following: ```console ... GET /admin/reviews HelloWeb.Admin.ReviewController :index GET /admin/reviews/:id/edit HelloWeb.Admin.ReviewController :edit GET /admin/reviews/new HelloWeb.Admin.ReviewController :new GET /admin/reviews/:id HelloWeb.Admin.ReviewController :show POST /admin/reviews HelloWeb.Admin.ReviewController :create PATCH /admin/reviews/:id HelloWeb.Admin.ReviewController :update PUT /admin/reviews/:id HelloWeb.Admin.ReviewController :update DELETE /admin/reviews/:id HelloWeb.Admin.ReviewController :delete ... ``` This looks good, but there is a problem here. Remember that we wanted both user-facing review routes `/reviews` and the admin ones `/admin/reviews`. If we now include the user-facing reviews in our router under the root scope like this: ```elixir scope "/", HelloWeb do pipe_through :browser ... resources "/reviews", ReviewController end scope "/admin", HelloWeb.Admin do pipe_through :browser resources "/reviews", ReviewController end ``` and we run `mix phx.routes`, we get output for each scoped route: ```console ... GET /reviews HelloWeb.ReviewController :index GET /reviews/:id/edit HelloWeb.ReviewController :edit GET /reviews/new HelloWeb.ReviewController :new GET /reviews/:id HelloWeb.ReviewController :show POST /reviews HelloWeb.ReviewController :create PATCH /reviews/:id HelloWeb.ReviewController :update PUT /reviews/:id HelloWeb.ReviewController :update DELETE /reviews/:id HelloWeb.ReviewController :delete ... GET /admin/reviews HelloWeb.Admin.ReviewController :index GET /admin/reviews/:id/edit HelloWeb.Admin.ReviewController :edit GET /admin/reviews/new HelloWeb.Admin.ReviewController :new GET /admin/reviews/:id HelloWeb.Admin.ReviewController :show POST /admin/reviews HelloWeb.Admin.ReviewController :create PATCH /admin/reviews/:id HelloWeb.Admin.ReviewController :update PUT /admin/reviews/:id HelloWeb.Admin.ReviewController :update DELETE /admin/reviews/:id HelloWeb.Admin.ReviewController :delete ``` What if we had a number of resources that were all handled by admins? We could put all of them inside the same scope like this: ```elixir scope "/admin", HelloWeb.Admin do pipe_through :browser resources "/images", ImageController resources "/reviews", ReviewController resources "/users", UserController end ``` Here's what `mix phx.routes` tells us: ```console ... GET /admin/images HelloWeb.Admin.ImageController :index GET /admin/images/:id/edit HelloWeb.Admin.ImageController :edit GET /admin/images/new HelloWeb.Admin.ImageController :new GET /admin/images/:id HelloWeb.Admin.ImageController :show POST /admin/images HelloWeb.Admin.ImageController :create PATCH /admin/images/:id HelloWeb.Admin.ImageController :update PUT /admin/images/:id HelloWeb.Admin.ImageController :update DELETE /admin/images/:id HelloWeb.Admin.ImageController :delete GET /admin/reviews HelloWeb.Admin.ReviewController :index GET /admin/reviews/:id/edit HelloWeb.Admin.ReviewController :edit GET /admin/reviews/new HelloWeb.Admin.ReviewController :new GET /admin/reviews/:id HelloWeb.Admin.ReviewController :show POST /admin/reviews HelloWeb.Admin.ReviewController :create PATCH /admin/reviews/:id HelloWeb.Admin.ReviewController :update PUT /admin/reviews/:id HelloWeb.Admin.ReviewController :update DELETE /admin/reviews/:id HelloWeb.Admin.ReviewController :delete GET /admin/users HelloWeb.Admin.UserController :index GET /admin/users/:id/edit HelloWeb.Admin.UserController :edit GET /admin/users/new HelloWeb.Admin.UserController :new GET /admin/users/:id HelloWeb.Admin.UserController :show POST /admin/users HelloWeb.Admin.UserController :create PATCH /admin/users/:id HelloWeb.Admin.UserController :update PUT /admin/users/:id HelloWeb.Admin.UserController :update DELETE /admin/users/:id HelloWeb.Admin.UserController :delete ``` This is great, exactly what we want. Note how every route and controller is properly namespaced. Scopes can also be arbitrarily nested, but you should do it carefully as nesting can sometimes make our code confusing and less clear. With that said, suppose that we had a versioned API with resources defined for images, reviews, and users. Then technically, we could set up routes for the versioned API like this: ```elixir scope "/api", HelloWeb.Api do pipe_through :api scope "/v1", V1 do resources "/images", ImageController resources "/reviews", ReviewController resources "/users", UserController end end ``` You can run `mix phx.routes` to see how these definitions will look like. Interestingly, we can use multiple scopes with the same path as long as we are careful not to duplicate routes. The following router is perfectly fine with two scopes defined for the same path: ```elixir defmodule HelloWeb.Router do use Phoenix.Router ... scope "/", HelloWeb do pipe_through :browser resources "/users", UserController end scope "/", AnotherAppWeb do pipe_through :browser resources "/posts", PostController end ... end ``` If we do duplicate a route — which means two routes having the same path — we'll get this familiar warning: ```console warning: this clause cannot match because a previous clause at line 16 always matches ``` ## Pipelines We have come quite a long way in this guide without talking about one of the first lines we saw in the router: `pipe_through :browser`. It's time to fix that. Pipelines are a series of plugs that can be attached to specific scopes. If you are not familiar with plugs, we have an [in-depth guide about them](plug.html). Routes are defined inside scopes and scopes may pipe through multiple pipelines. Once a route matches, Phoenix invokes all plugs defined in all pipelines associated to that route. For example, accessing `/` will pipe through the `:browser` pipeline, consequently invoking all of its plugs. Phoenix defines two pipelines by default, `:browser` and `:api`, which can be used for a number of common tasks. In turn we can customize them as well as create new pipelines to meet our needs. ### The `:browser` and `:api` pipelines As their names suggest, the `:browser` pipeline prepares for routes which render requests for a browser, and the `:api` pipeline prepares for routes which produce data for an API. The `:browser` pipeline has six plugs: The `plug :accepts, ["html"]` defines the accepted request format or formats. `:fetch_session`, which, naturally, fetches the session data and makes it available in the connection. `:fetch_live_flash`, which fetches any flash messages from LiveView and merges them with the controller flash messages. Then, the plug `:put_root_layout` will store the root layout for rendering purposes. Later `:protect_from_forgery` and `:put_secure_browser_headers`, protects form posts from cross-site forgery. Currently, the `:api` pipeline only defines `plug :accepts, ["json"]`. The router invokes a pipeline on a route defined within a scope. Routes outside of a scope have no pipelines. Although the use of nested scopes is discouraged (see above the versioned API example), if we call `pipe_through` within a nested scope, the router will invoke all `pipe_through`'s from parent scopes, followed by the nested one. Those are a lot of words bunched up together. Let's take a look at some examples to untangle their meaning. Here's another look at the router from a newly generated Phoenix application, this time with the `/api` scope uncommented back in and a route added. ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.Layouts, :root} plug :protect_from_forgery plug :put_secure_browser_headers end pipeline :api do plug :accepts, ["json"] end scope "/", HelloWeb do pipe_through :browser get "/", PageController, :home end # Other scopes may use custom stacks. scope "/api", HelloWeb do pipe_through :api resources "/reviews", ReviewController end # ... end ``` When the server accepts a request, the request will always first pass through the plugs in our endpoint, after which it will attempt to match on the path and HTTP verb. Let's say that the request matches our first route: a GET to `/`. The router will first pipe that request through the `:browser` pipeline - which will fetch the session data, fetch the flash, and execute forgery protection - before it dispatches the request to `PageController`'s `home` action. Conversely, suppose the request matches any of the routes defined by the [`resources/2`](`Phoenix.Router.resources/2`) macro. In that case, the router will pipe it through the `:api` pipeline — which currently only performs content negotiation — before it dispatches further to the correct action of the `HelloWeb.ReviewController`. If no route matches, no pipeline is invoked and a 404 error is raised. ### Creating new pipelines Phoenix allows us to create our own custom pipelines anywhere in the router. To do so, we call the [`pipeline/2`](`Phoenix.Router.pipeline/2`) macro with these arguments: an atom for the name of our new pipeline and a block with all the plugs we want in it. ```elixir defmodule HelloWeb.Router do use HelloWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {HelloWeb.Layouts, :root} plug :protect_from_forgery plug :put_secure_browser_headers end pipeline :auth do plug HelloWeb.Authentication end scope "/reviews", HelloWeb do pipe_through [:browser, :auth] resources "/", ReviewController end end ``` The above assumes there is a plug called `HelloWeb.Authentication` that performs authentication and is now part of the `:auth` pipeline. Note that pipelines themselves are plugs, so we can plug a pipeline inside another pipeline. For example, we could rewrite the `auth` pipeline above to automatically invoke `browser`, simplifying the downstream pipeline call: ```elixir pipeline :auth do plug :browser plug :ensure_authenticated_user plug :ensure_user_owns_review end scope "/reviews", HelloWeb do pipe_through :auth resources "/", ReviewController end ``` ## How to organize my routes? In Phoenix, we tend to define several pipelines, that provide specific functionality. For example, the `:browser` and `:api` pipelines are meant to be accessed by specific clients, browsers and http clients respectively. Perhaps more importantly, it is also very common to define pipelines specific to authentication and authorization. For example, you might have a pipeline that requires all users are authenticated. Another pipeline may enforce only admin users can access certain routes. Once your pipelines are defined, you reuse the pipelines in the desired scopes, grouping your routes around their pipelines. For example, going back to our reviews example. Let's say anyone can read a review, but only authenticated users can create them. Your routes could look like this: ```elixir pipeline :browser do ... end pipeline :auth do plug HelloWeb.Authentication end scope "/" do pipe_through [:browser] get "/reviews", PostController, :index get "/reviews/:id", PostController, :show end scope "/" do pipe_through [:browser, :auth] get "/reviews/new", PostController, :new post "/reviews", PostController, :create end ``` Note in the above how the routes are split across different scopes. While the separation can be confusing at first, it has one big upside: it is very easy to inspect your routes and see all routes that, for example, require authentication and which ones do not. This helps with auditing and making sure your routes have the proper scope. You can create as few or as many scopes as you want. Because pipelines are reusable across scopes, they help encapsulate common functionality and you can compose them as necessary on each scope you define. ## Forward The `Phoenix.Router.forward/4` macro can be used to send all requests that start with a particular path to a particular plug. Let's say we have a part of our system that is responsible (it could even be a separate application or library) for running jobs in the background, it could have its own web interface for checking the status of the jobs. We can forward to this admin interface using: ```elixir defmodule HelloWeb.Router do use HelloWeb, :router ... scope "/", HelloWeb do ... end forward "/jobs", BackgroundJob.Plug end ``` This means that all routes starting with `/jobs` will be sent to the `BackgroundJob.Plug` module. Inside the plug, you can match on subroutes, such as `/pending` and `/active` that shows the status of certain jobs. We can even mix the [`forward/4`](`Phoenix.Router.forward/4`) macro with pipelines. If we wanted to ensure that the user was authenticated and was an administrator in order to see the jobs page, we could use the following in our router. ```elixir defmodule HelloWeb.Router do use HelloWeb, :router ... scope "/" do pipe_through [:authenticate_user, :ensure_admin] forward "/jobs", BackgroundJob.Plug end end ``` This means the plugs in the `authenticate_user` and `ensure_admin` pipelines will be called before the `BackgroundJob.Plug` allowing them to send an appropriate response and halt the request accordingly. `BackgroundJob.Plug` can be implemented as any "Module Plug" discussed in the [Plug guide](plug.html). Note though it is not advised to forward to another Phoenix endpoint. This is because plugs defined by your app and the forwarded endpoint would be invoked twice, which may lead to errors. ## Summary Routing is a big topic, and we have covered a lot of ground here. The important points to take away from this guide are: - Routes which begin with an HTTP verb name expand to a single clause of the match function. - Routes declared with `resources` expand to 8 clauses of the match function. - Resources may restrict the number of match function clauses by using the `only:` or `except:` options. - Any of these routes may be nested. - Any of these routes may be scoped to a given path. - Using verified routes with `~p` for compile-time route checks ================================================ FILE: guides/security.md ================================================ # Security All software exposed to the public internet will be attacked. Most Phoenix applications fall into this category, so it is useful to understand common types of web application security vulnerabilities, the impact of each, and how to avoid them. Consider the following scenario: You are responsible for a banking application which handles transactions via a Phoenix backend. A new code change introduces a remote code execution (RCE) vulnerability, granting an attacker production SSH access to the server. This results in the database being exfiltrated, user accounts being compromised, and customer funds being stolen. With the rise of generative AI coding tools, proper judgement on the security of code has become more important than ever. This document will detail how severe vulnerabilities can occur in a Phoenix project and secure coding best practices to help avoid an incident. ## Remote Code Execution (RCE) A remote code execution (RCE) vulnerability grants an attacker the equivalent of production SSH access to your web server. This type of vulnerability is often considered the worst possible case, because it does not require user interaction and allows an attacker to bypass all security controls in your application. You should never pass untrusted user input to the following functions: ``` # Code functions Code.eval_string/3 Code.eval_file/2 Code.eval_quoted/3 # EEX functions eval_string/3 eval_file/3 # Command injection functions :os.cmd/2 System.cmd/3 System.shell/2 ``` All of these functions execute arbitrary code on your server if passed external input. The risk here is obvious to most programmers, so it is rare to find a Phoenix application vulnerable in this way. The more common and often unexpected way a Phoenix application is vulnerable to RCE is via the Erlang function `binary_to_term`. From [the Erlang docs:](https://www.erlang.org/doc/apps/erts/erlang.html#binary_to_term/2) > When decoding binaries from untrusted sources, the untrusted source may submit data in a way to create resources, such as atoms and remote references, that cannot be garbage collected and lead to a Denial of Service (DoS) attack. In such cases, use `binary_to_term/2` with the `safe` option. This warning is confusing, because the `safe` option mentioned above only prevents the creation of new atoms at runtime. It does not prevent the creation of executable terms via malicious user input, which is a much greater risk. ``` # Not safe :erlang.binary_to_term(user_input, [:safe]) # Safe Plug.Crypto.non_executable_binary_to_term(user_input, [:safe]) ``` The function `Plug.Crypto.non_executable_binary_to_term` prevents the creation of executable terms at runtime. If you are curious how this vulnerability can occur in the real world, see the writeup on [CVE-2020-15150 in the library Paginator.](https://www.alphabot.com/security/blog/2020/elixir/Remote-code-execution-vulnerability-in-Elixir-based-Paginator-project.html) ## SQL Injection SQL injection is on par with RCE as a highly severe vulnerability that leads to your entire database being leaked, and can even be leveraged to achieve code execution in some contexts. The good news for Phoenix developers is the majority of applications use Ecto, which is the interface to a dedicated database, typically PostgreSQL or MySQL. The Ecto query syntax protects against SQL injection by default: ``` # Safe, using query syntax def a_get_fruit(min_q) do from( f in Fruit, where: f.quantity >= ^min_q and f.secret == false ) |> Repo.all() end ``` The `fragment` function seems to be a vector for SQL injection: ``` # Fails to compile def b_get_fruit(min_q) do from( f in Fruit, where: fragment("f0.quantity >= #{min_q} AND f0.secret = FALSE") ) |> Repo.all() end ``` Yet if you try to compile the above code it fails: ```text Compiling 1 file (.ex) == Compilation error in file lib/basket/goods.ex == ** (Ecto.Query.CompileError) to prevent SQL injection attacks, fragment(...) does not allow strings to be interpolated as the first argument via the `^` operator, got: `"f0.quantity >= #{min_q} AND f0.secret = FALSE"` ``` What about passing arguments via fragment? ``` # Safe def c_get_fruit(min_q) do min_q = String.to_integer(min_q) from( f in Fruit, where: fragment("f0.quantity >= ? AND f0.secret = FALSE", ^min_q) ) |> Repo.all() end ``` The above code is safe because the external user input is safely parameterized into the query. What if you decide to pass arguments directly into raw SQL? ``` # Safe def d_get_fruit(min_q) do q = """ SELECT f.id, f.name, f.quantity, f.secret FROM fruits AS f WHERE f.quantity > $1 AND f.secret = FALSE """ {:ok, %{rows: rows}} = Ecto.Adapters.SQL.query(Repo, q, [String.to_integer(min_q)]) end ``` The above code is safe, similar to the fragment example, because the user input is being safely parameterized. Constructing a SQL query string via user input, then passing it directly to the query function does lead to SQL injection: ``` # Vulnerable to SQL injection def e_get_fruit(min_q) do q = """ SELECT f.id, f.name, f.quantity, f.secret FROM fruits AS f WHERE f.quantity > #{min_q} AND f.secret = FALSE """ {:ok, %{rows: rows}} = Ecto.Adapters.SQL.query(Repo, q) end ``` If you find yourself writing raw SQL, take care not to interpolate directly into the string, but rather use parameters for external input into the query. ## Server Side Request Forgery (SSRF) Server Side Request Forgery (SSRF) is a critical vulnerability that has been the root cause of major data breaches. The problem is untrusted user input being used to make outbound HTTP requests, which leads to the exploitation of services reachable from your Phoenix application. When you create a server in most cloud providers today, for example AWS EC2, there will be a [metadata service](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html) exposed on a private IP address. In the case of AWS it's on `169.254.169.254`. If you send an HTTP request to: `http://169.254.169.254/iam/security-credentials` From the server, it will return credentials for the AWS account. If you write a web application (for example in Phoenix) where a user can enter a URL, and then view the response of an HTTP request sent to that URL, that functionality is potentially vulnerable to SSRF. For a real world incident see [the Capital One breach.](https://dl.acm.org/doi/pdf/10.1145/3546068) Your reaction to this may be "This seems like an unsafe feature, considering they named an entire vulnerability class after it." You are not alone in this opinion, AWS introduced some SSRF specific mitigations in [2019 via IMDSv2](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/), requiring HTTP requests to the metadata endpoint to have session authentication. The instance metadata service of cloud servers is not the only target for SSRF: services such as PostgreSQL, MySQL, Redis, Elasticsearch, even custom micro-services that you believe are not exposed to the public internet may be vulnerable to SSRF. Consider an internal server with vulnerabilities that can be exploited via HTTP requests, not directly exposed to the public internet. Yet if that network also has a Phoenix application vulnerable to SSRF, an attacker can go through the Phoenix server to attack the private server. To summarize, using an HTTP client does not necessarily mean your application is vulnerable to SSRF. Rather the following conditions must be met: 1. You are using external user input to construct URLs 2. An attacker is able to send HTTP requests to some vulnerable server on your network For an Elixir specific example consider the Req library: ``` req = Req.new(base_url: "https://api.github.com") Req.get!(req, url: "/repos/sneako/finch").body["description"] #=> "Elixir HTTP client, focused on performance" ``` It is possible to override the `base_url` value: ``` req = Req.new(base_url: "https://elixir-lang.org/") user_input = "https://dashbit.co/blog" Req.get!(req, url: user_input) ``` The above code sends a request to `https://dashbit.co/blog`, NOT `https://elixir-lang.org/`. Consider a similar example in Tesla: ``` plug Tesla.Middleware.BaseUrl, "https://example.com/foo" MyClient.get("http://example.com/bar") # equals to GET http://example.com/bar ``` Even if you are setting a base URL in your application, don't treat it as a security barrier, because as these examples show it can be overwritten. Take care to avoid sending HTTP requests based on user input if you can avoid it, and be mindful of services on the same network as your Phoenix application that could be exploited via SSRF. ## Cross Origin Resource Sharing (CORS) Misconfiguration Cross Origin Resource Sharing (CORS) is a feature in modern web browsers which can be used to bypass the same origin policy, which is useful because your application can now load resources from a different site in the user's web browser. This is normally restricted by default. Consider a Phoenix API with a single page application (SPA) on a different domain: `app.example.com` - React frontend `api.example.com` - Backend in Elixir/Phoenix The frontend `(app.example.com)` needs to fetch information about the current user, however the origins of these projects are different. The user's web browser will block the request unless CORS is enabled between the sites. Setting the following in the Phoenix application: ``` plug CORSPlug, origin: ["https://app.example.com"] ``` Is the correct way to do this. However it is also possible to set a policy that is far too broad, for example: ``` plug CORSPlug, origin: ~r/^http.*/ ``` This is a major security risk, because now a malicious site loaded by a user who is logged into the application can read sensitive data, for example API keys. Take care to ensure only trusted sites are allowed here. ## Broken Access Control In Phoenix controllers the standard way to handle authorization is putting the current user in the assigns, and then doing: ``` user = conn.assigns.current_user ``` Many projects add this as a third argument in the controller actions: ``` def action(conn, _) do args = [conn, conn.params, conn.assigns.current_user] apply(__MODULE__, action_name(conn), args) end ``` This is the correct approach. The wrong approach is to accept arbitrary user input when making authorization decisions, for example: ``` # Not safe def index(conn, %{"user" => user_email}) user = Accounts.get_user_by_email(user_email) ``` In the above example an attacker can simply change the submitted `user_email` string to an arbitrary value to perform an action as a different user. Using `conn.assigns.current_user` avoids this problem. Related to the above concept, the design of Ecto in Phoenix takes the risk of mass assignment into consideration, because you have to explicitly define what parameters are allowed to be set from user supplied data. Consider a simple users schema: ``` schema "users" do field :email, :string field :password, :string, virtual: true, redact: true field :hashed_password, :string, redact: true field :confirmed_at, :naive_datetime field :is_admin, :boolean timestamps(type: :utc_datetime) end def registration_changeset(user, attrs, opts \\ []) do user |> cast(attrs, [:email, :password, :is_admin]) |> validate_email() |> validate_password(opts) end ``` Assume that the corresponding signup form is exposed to the public internet. Can you spot the vulnerability? The problem is that `:is_admin` should never be set via external user input. Anyone on the public internet can now create a user where `:is_admin` is set to true in the database, which is likely not the intent of the developer. ## Cross Site Scripting (XSS) By default, user input in Phoenix is escaped so that: ``` <%= "" %> ``` is shown in your browser as: ```text <hello> ``` Note that this looks like a normal string of `` from an end user perspective, the `<` and `>` are only visible if you inspect the page with your browser tools. It is possible to bypass this protection via the `raw/1` function. For example, consider the string `hello`. ``` # This will render the literal string hello <%= "hello" %> # This will render a bold hello <%= raw "hello" %> ``` With the ability to inject script tags, an attacker now has the ability to execute JavaScript in a victim's browser, for example by submitting a string such as: ```html ``` If someone submits the above input to your application, and it is displayed to logged in users, you have a serious problem. See the [2005 MySpace worm](https://en.wikipedia.org/wiki/Samy_(computer_worm)) for a real world example of this. User input should never be passed into the `raw/1` function. There are some additional vectors for XSS in Phoenix applications, for example consider the following controller functions: ``` def html_resp(conn, %{"i" => i}) do html(conn, "#{i}") end ``` Because the HTML is being generated from user input, the function is vulnerable to XSS. This can also happen with `put_resp_content_type`: ``` def send_resp_html(conn, %{"i" => i}) do conn |> put_resp_content_type("text/html") |> send_resp(200, "#{i}") end ``` File uploads can also lead to XSS. ``` def new_upload(conn, _params) do render(conn, "new_upload.html") end def upload(conn, %{"upload" => upload}) do %Plug.Upload{content_type: content_type, filename: filename, path: path} = upload ImgServer.put(filename, %{content_type: content_type, bin: File.read!(path)}) redirect(conn, to: Routes.page_path(conn, :view_photo, filename)) end def view_photo(conn, %{"filename" => filename}) do case ImgServer.get(filename) do %{content_type: content_type, bin: bin} -> conn |> put_resp_content_type(content_type) |> send_resp(200, bin) _ -> conn |> put_resp_content_type("text/html") |> send_resp(404, "Not Found") end end ``` User input determines the `content-type` of the file. There is no validation on the type of file being uploaded, meaning `content-type` can be set so an HTML page is rendered. This is the source of the vulnerability. Consider the file `xss.html`, with the contents: ```html ``` This will result in JavaScript being executed in the browser of the victim who views the image. Restricting the `put_resp_content_type` argument to only image files would fix this vulnerability. ## Cross Site Request Forgery (CSRF) ### Standard CSRF in HTML forms Cross site request forgery (CSRF) is a vulnerability that exists due to a quirk in how web browsers work. Consider a social media website that is vulnerable to CSRF. An attacker creates a malicious website aimed at legitimate users. When a victim visits the malicious site, it triggers a POST request in the victim’s browser, sending a message that was written by the attacker. This results in the victim’s account making a post written by the attacker. But why is this possible? Shouldn't the web browser block POST requests initiated by a different website? There is a cookie feature called SameSite that addresses this problem, however it's good to understand what CSRF is and why Phoenix has built in protections. Consider the following form: ```html
``` This maps to the following HTTP request: ```http_request_and_response POST /posts HTTP/1.1 Host: example.com Content-Type: application/x-www-form-urlencoded Content-Length: 53 post[title]=My+Title&post[body]=This+is+the+body ``` An attacker can embed the following form on `attacker.com`: ```html
``` Note that this form does not even have to be visible to the victim user. When the user visits `attacker.com` the form will automatically submit a POST request on behalf of the victim, with the victim's current session cookie, to the vulnerable site. The way most web frameworks, including Phoenix, mitigate this vulnerability is by requiring a CSRF token when submitting a form. ```html ``` This changes the previous HTTP request to: ```http_request_and_response POST /posts HTTP/1.1 Host: example.com Content-Type: application/x-www-form-urlencoded Content-Length: 53 post[title]=My+Title&post[body]=This+is+the+body&post[_csrf_token]=WUZXJh07BhAIJ24jP1d-KQEpLwYmMDwQ0-2eYNLH_x8oHoO_qv_HJDqZ ``` Because the token is randomly generated, an attacker cannot predict what the value will be. The application is safe against CSRF attacks because Phoenix checks the value of this token by default via the `:protect_from_forgery` plug, which is included in the default `:browser` pipeline of a new Phoenix project: ``` # router.ex pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, {CarafeWeb.LayoutView, :root} plug :protect_from_forgery # <-- Checks the CSRF token value plug :put_secure_browser_headers plug :fetch_current_user end ``` CSRF protections are included in Phoenix by default, so your application is most likely not vulnerable if you are using the default settings. ### Action Re-Use CSRF Most descriptions of CSRF focus on state changing POST requests and the need for random tokens, as was just covered. Is CSRF possible with a GET request? Yes, GET requests should never be used to perform state changing actions in a web application (place an order, transfer money, etc) because they cannot be protected against CSRF in the same way POST requests can. Consider the following form: ```heex <.form :let={f} for={@bio_changeset} action={~p"/users/settings/edit_bio"} method="post" id="edit_bio">
<%= label f, :bio %> <%= textarea f, :bio, required: true, class: "" %> <%= error_tag f, :bio %>
<%= submit "Update Bio", class: "" %>
``` Submitting this form triggers a POST request: ```text [info] POST /users/settings/edit_bio [debug] Processing with CarafeWeb.UserSettingsController.edit_bio/2 Parameters: %{"_csrf_token" => "cigMDlcdAnxbWW88OAAiBHoZZ3cmCW0l1refzZ7D666RWvjCLi02UZXq", "user" => %{"bio" => "My bio here"}} Pipelines: [:browser, :require_authenticated_user] ``` The important point is that the above parameters match the route and controller action: ``` # router.ex post "/users/settings/edit_bio", UserSettingsController, :edit_bio # user_settings_controller.ex def edit_bio(conn, %{"user" => params}) do case Accounts.update_user_bio(conn.assigns.current_user, params) do {:ok, _bio} -> conn |> put_flash(:info, "Bio Update Successful") |> redirect(to: Routes.user_settings_path(conn, :edit)) {:error, changeset} -> render(conn, "edit.html", bio_changeset: changeset) end end ``` The parameters: ``` %{"_csrf_token" => "cigMDlcdAnxbWW88OAAiBHoZZ3cmCW0l1refzZ7D666RWvjCLi02UZXq", "user" => %{"bio" => "My bio here"}} ``` Match the `edit_bio/2` action. Note that the `_csrf_token` is processed in the router by the plug `:protect_from_forgery` built into Phoenix. Now consider the following update to the router: ``` # router.ex get "/users/settings/edit_bio", UserSettingsController, :edit_bio post "/users/settings/edit_bio", UserSettingsController, :edit_bio ``` Allowing access to the `edit_bio/2` controller action via a GET request introduces an action re-use CSRF vulnerability. If the victim visits the following URL: `/users/settings/edit_bio?user%5Bbio%5D=Hacked+LOL` It will trigger the following: ```text [info] GET /users/settings/edit_bio [debug] Processing with CarafeWeb.UserSettingsController.edit_bio/2 Parameters: %{"user" => %{"bio" => "Hacked LOL"}} Pipelines: [:browser, :require_authenticated_user] ``` These parameters will match the `edit_bio/2` controller action, updating the user biography. The key lesson here is that state changing actions (transferring money, creating a post, updating account information) should occur via a POST request with proper CSRF protections, never via a GET request. ## Further Reading The Erlang Ecosystem Foundation also publishes in-depth documents which are relevant for Erlang, Elixir, and Phoenix developers. These include: * [Web Application Security Best Practices for BEAM languages](https://security.erlef.org/web_app_security_best_practices_beam/) * [Secure Coding and Deployment Hardening Guidelines](https://security.erlef.org/secure_coding_and_deployment_hardening/) ================================================ FILE: guides/telemetry.md ================================================ # Telemetry In this guide, we will show you how to instrument and report on `:telemetry` events in your Phoenix application. > `te·lem·e·try` - the process of recording and transmitting the readings of an instrument. As you follow along with this guide, we will introduce you to the core concepts of Telemetry, you will initialize a reporter to capture your application's events as they occur, and we will guide you through the steps to properly instrument your own functions using `:telemetry`. Let's take a closer look at how Telemetry works in your application. ## Overview The `:telemetry` library allows you to emit events at various stages of an application's lifecycle. You can then respond to these events by, among other things, aggregating them as metrics and sending the metrics data to a reporting destination. Telemetry stores events by their name in an ETS table, along with the handler for each event. Then, when a given event is executed, Telemetry looks up its handler and invokes it. Phoenix's Telemetry tooling provides you with a supervisor that uses `Telemetry.Metrics` to define the list of Telemetry events to handle and how to handle those events, i.e. how to structure them as a certain type of metric. This supervisor works together with Telemetry reporters to respond to the specified Telemetry events by aggregating them as the appropriate metric and sending them to the correct reporting destination. ## The Telemetry supervisor Since v1.5, new Phoenix applications are generated with a Telemetry supervisor. This module is responsible for managing the lifecycle of your Telemetry processes. It also defines a `metrics/0` function, which returns a list of [`Telemetry.Metrics`](https://hexdocs.pm/telemetry_metrics) that you define for your application. By default, the supervisor also starts [`:telemetry_poller`](https://hexdocs.pm/telemetry_poller). By simply adding `:telemetry_poller` as a dependency, you can receive VM-related events on a specified interval. If you are coming from an older version of Phoenix, install the `:telemetry_metrics` and `:telemetry_poller` packages: ```elixir {:telemetry_metrics, "~> 1.0"}, {:telemetry_poller, "~> 1.0"} ``` and create your Telemetry supervisor at `lib/my_app_web/telemetry.ex`: ```elixir # lib/my_app_web/telemetry.ex defmodule MyAppWeb.Telemetry do use Supervisor import Telemetry.Metrics def start_link(arg) do Supervisor.start_link(__MODULE__, arg, name: __MODULE__) end def init(_arg) do children = [ {: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.stop.duration", unit: {:native, :millisecond} ), summary("phoenix.router_dispatch.stop.duration", tags: [:route], unit: {:native, :millisecond} ), # 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. # {MyApp, :count_users, []} ] end end ``` Make sure to replace MyApp by your actual application name. Then add to your main application's supervision tree (usually in `lib/my_app/application.ex`): ```elixir children = [ MyAppWeb.Telemetry, MyApp.Repo, MyAppWeb.Endpoint, ... ] ``` ## Telemetry Events Many Elixir libraries (including Phoenix) are already using the [`:telemetry`](https://hexdocs.pm/telemetry) package as a way to give users more insight into the behavior of their applications, by emitting events at key moments in the application lifecycle. A Telemetry event is made up of the following: * `name` - A string (e.g. `"my_app.worker.stop"`) or a list of atoms that uniquely identifies the event. * `measurements` - A map of atom keys (e.g. `:duration`) and numeric values. * `metadata` - A map of key-value pairs that can be used for tagging metrics. ### A Phoenix Example Here is an example of an event from your endpoint: * `[:phoenix, :endpoint, :stop]` - dispatched by `Plug.Telemetry`, one of the default plugs in your endpoint, whenever the response is sent * Measurement: `%{duration: native_time}` * Metadata: `%{conn: Plug.Conn.t}` This means that after each request, `Plug`, via `:telemetry`, will emit a "stop" event, with a measurement of how long it took to get the response: ```elixir :telemetry.execute([:phoenix, :endpoint, :stop], %{duration: duration}, %{conn: conn}) ``` ### Phoenix Telemetry Events A full list of all Phoenix telemetry events can be found in `Phoenix.Logger` ## Metrics > Metrics are aggregations of Telemetry events with a > specific name, providing a view of the system's behaviour > over time. > > ― `Telemetry.Metrics` The Telemetry.Metrics package provides a common interface for defining metrics. It exposes a set of [five metric type functions](https://hexdocs.pm/telemetry_metrics/Telemetry.Metrics.html#module-metrics) that are responsible for structuring a given Telemetry event as a particular measurement. The package does not perform any aggregation of the measurements itself. Instead, it provides a reporter with the Telemetry event-as-measurement definition and the reporter uses that definition to perform aggregations and report them. We will discuss reporters in the next section. Let's take a look at some examples. Using `Telemetry.Metrics`, you can define a counter metric, which counts how many HTTP requests were completed: ```elixir Telemetry.Metrics.counter("phoenix.endpoint.stop.duration") ``` or you could use a distribution metric to see how many requests were completed in particular time buckets: ```elixir Telemetry.Metrics.distribution("phoenix.endpoint.stop.duration") ``` This ability to introspect HTTP requests is really powerful -- and this is but one of _many_ telemetry events emitted by the Phoenix framework! We'll discuss more of these events, as well as specific patterns for extracting valuable data from Phoenix/Plug events in the [Phoenix Metrics](#phoenix-metrics) section later in this guide. > The full list of `:telemetry` events emitted from Phoenix, along with their measurements and metadata, is available in the "Instrumentation" section of the `Phoenix.Logger` module documentation. ### An Ecto Example Like Phoenix, Ecto ships with built-in Telemetry events. This means that you can gain introspection into your web and database layers using the same tools. Here is an example of a Telemetry event executed by Ecto when an Ecto repository starts: * `[:ecto, :repo, :init]` - dispatched by `Ecto.Repo` * Measurement: `%{system_time: native_time}` * Metadata: `%{repo: Ecto.Repo, opts: Keyword.t()}` This means that whenever the `Ecto.Repo` starts, it will emit an event, via `:telemetry`, with a measurement of the time at start-up. ```elixir :telemetry.execute([:ecto, :repo, :init], %{system_time: System.system_time()}, %{repo: repo, opts: opts}) ``` Additional Telemetry events are executed by Ecto adapters. One such adapter-specific event is the `[:my_app, :repo, :query]` event. For instance, if you want to graph query execution time, you can use the `Telemetry.Metrics.summary/2` function to instruct your reporter to calculate statistics of the `[:my_app, :repo, :query]` event, like maximum, mean, percentiles etc.: ```elixir Telemetry.Metrics.summary("my_app.repo.query.query_time", unit: {:native, :millisecond} ) ``` Or you could use the `Telemetry.Metrics.distribution/2` function to define a histogram for another adapter-specific event: `[:my_app, :repo, :query, :queue_time]`, thus visualizing how long queries spend queued: ```elixir Telemetry.Metrics.distribution("my_app.repo.query.queue_time", unit: {:native, :millisecond} ) ``` > You can learn more about Ecto Telemetry in the "Telemetry Events" section of the [`Ecto.Repo`](https://hexdocs.pm/ecto/Ecto.Repo.html) module documentation. So far we have seen some of the Telemetry events common to Phoenix applications, along with some examples of their various measurements and metadata. With all of this data just waiting to be consumed, let's talk about reporters. ## Reporters Reporters subscribe to Telemetry events using the common interface provided by `Telemetry.Metrics`. They then aggregate the measurements (data) into metrics to provide meaningful information about your application. For example, if the following `Telemetry.Metrics.summary/2` call is added to the `metrics/0` function of your Telemetry supervisor: ```elixir summary("phoenix.endpoint.stop.duration", unit: {:native, :millisecond} ) ``` Then the reporter will attach a listener for the `"phoenix.endpoint.stop.duration"` event and will respond to this event by calculating a summary metric with the given event metadata and reporting on that metric to the appropriate source. ### Phoenix.LiveDashboard For developers interested in real-time visualizations for their Telemetry metrics, you may be interested in installing [`LiveDashboard`](https://hexdocs.pm/phoenix_live_dashboard). LiveDashboard acts as a Telemetry.Metrics reporter to render your data as beautiful, real-time charts on the dashboard. ### Telemetry.Metrics.ConsoleReporter `Telemetry.Metrics` ships with a `ConsoleReporter` that can be used to print events and metrics to the terminal. You can use this reporter to experiment with the metrics discussed in this guide. Uncomment or add the following to this list of children in your Telemetry supervision tree (usually in `lib/my_app_web/telemetry.ex`): ```elixir {Telemetry.Metrics.ConsoleReporter, metrics: metrics()} ``` > There are numerous reporters available, for services like > StatsD, Prometheus, and more. You can find them by > searching for "telemetry_metrics" on [hex.pm](https://hex.pm/packages?search=telemetry_metrics). ## Phoenix Metrics Earlier we looked at the "stop" event emitted by `Plug.Telemetry`, and used it to count the number of HTTP requests. In reality, it's only somewhat helpful to be able to see just the total number of requests. What if you wanted to see the number of requests per route, or per route _and_ method? Let's take a look at another event emitted during the HTTP request lifecycle, this time from `Phoenix.Router`: * `[:phoenix, :router_dispatch, :stop]` - dispatched by Phoenix.Router after successfully dispatching to a matched route * Measurement: `%{duration: native_time}` * Metadata: `%{conn: Plug.Conn.t, route: binary, plug: module, plug_opts: term, path_params: map, pipe_through: [atom]}` Let's start by grouping these events by route. Add the following (if it does not already exist) to the `metrics/0` function of your Telemetry supervisor (usually in `lib/my_app_web/telemetry.ex`): ```elixir # lib/my_app_web/telemetry.ex def metrics do [ ...metrics... summary("phoenix.router_dispatch.stop.duration", tags: [:route], unit: {:native, :millisecond} ) ] end ``` Restart your server, and then make requests to a page or two. In your terminal, you should see the ConsoleReporter print logs for the Telemetry events it received as a result of the metrics definitions you provided. The log line for each request contains the specific route for that request. This is due to specifying the `:tags` option for the summary metric, which takes care of our first requirement; we can use `:tags` to group metrics by route. Note that reporters will necessarily handle tags differently depending on the underlying service in use. Looking more closely at the Router "stop" event, you can see that the `Plug.Conn` struct representing the request is present in the metadata, but how do you access the properties in `conn`? Fortunately, `Telemetry.Metrics` provides the following options to help you classify your events: * `:tags` - A list of metadata keys for grouping; * `:tag_values` - A function which transforms the metadata into the desired shape; Note that this function is called for each event, so it's important to keep it fast if the rate of events is high. > Learn about all the available metrics options in the `Telemetry.Metrics` module documentation. Let's find out how to extract more tags from events that include a `conn` in their metadata. ### Extracting tag values from Plug.Conn Let's add another metric for the route event, this time to group by route and method: ```elixir summary("phoenix.router_dispatch.stop.duration", tags: [:method, :route], tag_values: &get_and_put_http_method/1, unit: {:native, :millisecond} ) ``` We've introduced the `:tag_values` option here, because we need to perform a transformation on the event metadata in order to get to the values we need. Add the following private function to your Telemetry module to lift the `:method` value from the `Plug.Conn` struct: ```elixir # lib/my_app_web/telemetry.ex defp get_and_put_http_method(%{conn: %{method: method}} = metadata) do Map.put(metadata, :method, method) end ``` Restart your server and make some more requests. You should begin to see logs with tags for both the HTTP method and the route. Note the `:tags` and `:tag_values` options can be applied to all `Telemetry.Metrics` types. ### Renaming value labels using tag values Sometimes when displaying a metric, the value label may need to be transformed to improve readability. Take for example the following metric that displays the duration of the each LiveView's `mount/3` callback by `connected?` status. ```elixir summary("phoenix.live_view.mount.stop.duration", unit: {:native, :millisecond}, tags: [:view, :connected?], tag_values: &live_view_metric_tag_values/1 ) ``` The following function lifts `metadata.socket.view` and `metadata.socket.connected?` to be top-level keys on `metadata`, as we did in the previous example. ```elixir # lib/my_app_web/telemetry.ex defp live_view_metric_tag_values(metadata) do metadata |> Map.put(:view, metadata.socket.view) |> Map.put(:connected?, Phoenix.LiveView.connected?(metadata.socket)) end ``` However, when rendering these metrics in LiveDashboard, the value label is output as `"Elixir.Phoenix.LiveDashboard.MetricsLive true"`. To make the value label easier to read, we can update our private function to generate more user friendly names. We'll run the value of the `:view` through `inspect/1` to remove the `Elixir.` prefix and call another private function to convert the `connected?` boolean into human readable text. ```elixir # lib/my_app_web/telemetry.ex defp live_view_metric_tag_values(metadata) do metadata |> Map.put(:view, inspect(metadata.socket.view)) |> Map.put(:connected?, get_connection_status(Phoenix.LiveView.connected?(metadata.socket))) end defp get_connection_status(true), do: "Connected" defp get_connection_status(false), do: "Disconnected" ``` Now the value label will be rendered like `"Phoenix.LiveDashboard.MetricsLive Connected"`. Hopefully, this gives you some inspiration on how to use the `:tag_values` option. Just remember to keep this function fast since it is called on every event. ## Periodic measurements You might want to periodically measure key-value pairs within your application. Fortunately the [`:telemetry_poller`](https://hexdocs.pm/telemetry_poller) package provides a mechanism for custom measurements, which is useful for retrieving process information or for performing custom measurements periodically. Add the following to the list in your Telemetry supervisor's `periodic_measurements/0` function, which is a private function that returns a list of measurements to take on a specified interval. ```elixir # lib/my_app_web/telemetry.ex defp periodic_measurements do [ {MyApp, :measure_users, []}, {:process_info, event: [:my_app, :my_server], name: MyApp.MyServer, keys: [:message_queue_len, :memory]} ] end ``` where `MyApp.measure_users/0` could be written like this: ```elixir # lib/my_app.ex defmodule MyApp do def measure_users do :telemetry.execute([:my_app, :users], %{total: MyApp.users_count()}, %{}) end end ``` Now with measurements in place, you can define the metrics for the events above: ```elixir # lib/my_app_web/telemetry.ex def metrics do [ ...metrics... # MyApp Metrics last_value("my_app.users.total"), last_value("my_app.my_server.memory", unit: :byte), last_value("my_app.my_server.message_queue_len") summary("my_app.my_server.call.stop.duration"), counter("my_app.my_server.call.exception") ] end ``` > You will implement MyApp.MyServer in the [Custom Events](#custom-events) section. ## Libraries using Telemetry Telemetry is quickly becoming the de-facto standard for package instrumentation in Elixir. Here is a list of libraries currently emitting `:telemetry` events. Library authors are actively encouraged to send a PR adding their own (in alphabetical order, please): * [Absinthe](https://hexdocs.pm/absinthe) - [Events](https://hexdocs.pm/absinthe/telemetry.html) * [Ash Framework](https://hexdocs.pm/ash) - [Events](https://hexdocs.pm/ash/monitoring.html) * [Broadway](https://hexdocs.pm/broadway) - [Events](https://hexdocs.pm/broadway/Broadway.html#module-telemetry) * [Ecto](https://hexdocs.pm/ecto) - [Events](https://hexdocs.pm/ecto/Ecto.Repo.html#module-telemetry-events) * [Oban](https://hexdocs.pm/oban) - [Events](https://hexdocs.pm/oban/Oban.Telemetry.html) * [Phoenix](https://hexdocs.pm/phoenix) - [Events](https://hexdocs.pm/phoenix/Phoenix.Logger.html#module-instrumentation) * [Plug](https://hexdocs.pm/plug) - [Events](https://hexdocs.pm/plug/Plug.Telemetry.html) * [Tesla](https://hexdocs.pm/tesla) - [Events](https://hexdocs.pm/tesla/Tesla.Middleware.Telemetry.html) ## Custom Events If you need custom metrics and instrumentation in your application, you can utilize the `:telemetry` package () just like your favorite frameworks and libraries. Here is an example of a simple GenServer that emits telemetry events. Create this file in your app at `lib/my_app/my_server.ex`: ```elixir # lib/my_app/my_server.ex defmodule MyApp.MyServer do @moduledoc """ An example GenServer that runs arbitrary functions and emits telemetry events when called. """ use GenServer # A common prefix for :telemetry events @prefix [:my_app, :my_server, :call] def start_link(fun) do GenServer.start_link(__MODULE__, fun, name: __MODULE__) end @doc """ Runs the function contained within this server. ## Events The following events may be emitted: * `[:my_app, :my_server, :call, :start]` - Dispatched immediately before invoking the function. This event is always emitted. * Measurement: `%{system_time: system_time}` * Metadata: `%{}` * `[:my_app, :my_server, :call, :stop]` - Dispatched immediately after successfully invoking the function. * Measurement: `%{duration: native_time}` * Metadata: `%{}` * `[:my_app, :my_server, :call, :exception]` - Dispatched immediately after invoking the function, in the event the function throws or raises. * Measurement: `%{duration: native_time}` * Metadata: `%{kind: kind, reason: reason, stacktrace: stacktrace}` """ def call!, do: GenServer.call(__MODULE__, :called) @impl true def init(fun) when is_function(fun, 0), do: {:ok, fun} @impl true def handle_call(:called, _from, fun) do # Wrap the function invocation in a "span" result = telemetry_span(fun) {:reply, result, fun} end # Emits telemetry events related to invoking the function defp telemetry_span(fun) do start_time = emit_start() try do fun.() catch kind, reason -> stacktrace = System.stacktrace() duration = System.monotonic_time() - start_time emit_exception(duration, kind, reason, stacktrace) :erlang.raise(kind, reason, stacktrace) else result -> duration = System.monotonic_time() - start_time emit_stop(duration) result end end defp emit_start do start_time_mono = System.monotonic_time() :telemetry.execute( @prefix ++ [:start], %{system_time: System.system_time()}, %{} ) start_time_mono end defp emit_stop(duration) do :telemetry.execute( @prefix ++ [:stop], %{duration: duration}, %{} ) end defp emit_exception(duration, kind, reason, stacktrace) do :telemetry.execute( @prefix ++ [:exception], %{duration: duration}, %{ kind: kind, reason: reason, stacktrace: stacktrace } ) end end ``` and add it to your application's supervisor tree (usually in `lib/my_app/application.ex`), giving it a function to invoke when called: ```elixir # lib/my_app/application.ex children = [ # Start a server that greets the world {MyApp.MyServer, fn -> "Hello, world!" end}, ] ``` Now start an IEx session and call the server: ```elixir iex> MyApp.MyServer.call! ``` and you should see something like the following output: ```text [Telemetry.Metrics.ConsoleReporter] Got new event! Event name: my_app.my_server.call.stop All measurements: %{duration: 4000} All metadata: %{} Metric measurement: #Function<2.111777250/1 in Telemetry.Metrics.maybe_convert_measurement/2> (summary) With value: 0.004 millisecond Tag values: %{} "Hello, world!" ``` ================================================ FILE: guides/testing/testing.md ================================================ # Introduction to Testing > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). Testing has become integral to the software development process, and the ability to easily write meaningful tests is an indispensable feature for any modern web framework. Phoenix takes this seriously, providing support files to make all the major components of the framework easy to test. It also generates test modules with real-world examples alongside any generated modules to help get us going. Elixir ships with a built-in testing framework called [ExUnit](https://hexdocs.pm/ex_unit). ExUnit strives to be clear and explicit, keeping magic to a minimum. Phoenix uses ExUnit for all of its testing, and we will use it here as well. ## Running tests When Phoenix generates a web application for us, it also includes tests. To run them, simply type `mix test`: ```console $ mix test .... Finished in 0.09 seconds 5 tests, 0 failures Randomized with seed 652656 ``` We already have five tests! In fact, we already have a directory structure completely set up for testing, including a test helper and support files. ```console test ├── hello_web │   └── controllers │      ├── error_html_test.exs │      ├── error_json_test.exs │      └── page_controller_test.exs ├── support │   ├── conn_case.ex │   └── data_case.ex └── test_helper.exs ``` The test cases we get for free include those from `test/hello_web/controllers/`. They are testing our controllers and views. If you haven't read the guides for controllers and views, now is a good time. ## Understanding test modules We are going to use the next sections to get acquainted with Phoenix testing structure. We will start with the three test files generated by Phoenix. The first test file we'll look at is `test/hello_web/controllers/page_controller_test.exs`. ```elixir defmodule HelloWeb.PageControllerTest do use HelloWeb.ConnCase test "GET /", %{conn: conn} do conn = get(conn, ~p"/") assert html_response(conn, 200) =~ "Peace of mind from prototype to production" end end ``` There are a couple of interesting things happening here. Our test files simply define modules. At the top of each module, you will find a line such as: ```elixir use HelloWeb.ConnCase ``` If you were to write an Elixir library, outside of Phoenix, instead of `use HelloWeb.ConnCase` you would write `use ExUnit.Case`. However, Phoenix already ships with a bunch of functionality for testing controllers and `HelloWeb.ConnCase` builds on top of `ExUnit.Case` to bring these functionalities in. We will explore the `HelloWeb.ConnCase` module soon. Then we define each test using the `test/3` macro. The `test/3` macro receives three arguments: the test name, the testing context that we are pattern matching on, and the contents of the test. In this test, we access the root page of our application by a "GET" HTTP request on the path "/" with the `get/2` macro. Then we **assert** that the rendered page contains the string "Peace of mind from prototype to production". When writing tests in Elixir, we use assertions to check that something is true. In our case, `assert html_response(conn, 200) =~ "Peace of mind from prototype to production"` is doing a couple things: * It asserts that `conn` has rendered a response * It asserts that the response has the 200 status code (which means OK in HTTP parlance) * It asserts that the type of the response is HTML * It asserts that the result of `html_response(conn, 200)`, which is an HTML response, has the string "Peace of mind from prototype to production" in it However, from where does the `conn` we use on `get` and `html_response` come from? To answer this question, let's take a look at `HelloWeb.ConnCase`. ## The ConnCase If you open up `test/support/conn_case.ex`, you will find this (with comments removed): ```elixir defmodule HelloWeb.ConnCase do use ExUnit.CaseTemplate using do quote do # The default endpoint for testing @endpoint HelloWeb.Endpoint use HelloWeb, :verified_routes # Import conveniences for testing with connections import Plug.Conn import Phoenix.ConnTest import HelloWeb.ConnCase end end setup tags do Hello.DataCase.setup_sandbox(tags) {:ok, conn: Phoenix.ConnTest.build_conn()} end end ``` There is a lot to unpack here. The second line says this is a case template. This is a ExUnit feature that allows developers to replace the built-in `use ExUnit.Case` by their own case. This line is pretty much what allows us to write `use HelloWeb.ConnCase` at the top of our controller tests. Now that we have made this module a case template, we can define callbacks that are invoked on certain occasions. The `using` callback defines code to be injected on every module that calls `use HelloWeb.ConnCase`. In this case, it starts by setting the `@endpoint` module attribute with the name of our endpoint. Next, it wires up `:verified_routes` to allow us to use `~p` based paths in our test just like we do in the rest of our application to easily generate paths and URLs in our tests. Finally, we import [`Plug.Conn`](https://hexdocs.pm/plug/Plug.Conn.html), so all of the connection helpers available in controllers are also available in tests, and then imports [`Phoenix.ConnTest`](https://hexdocs.pm/phoenix/Phoenix.ConnTest.html). You can consult these modules to learn all functionality available. Then our case template defines a `setup` block. The `setup` block will be called before test. Most of the setup block is on setting up the SQL Sandbox, which we will talk about later. In the last line of the `setup` block, we will find this: ```elixir {:ok, conn: Phoenix.ConnTest.build_conn()} ``` The last line of `setup` can return test metadata that will be available in each test. The metadata we are passing forward here is a newly built `Plug.Conn`. In our test, we extract the connection out of this metadata at the very beginning of our test: ```elixir test "GET /", %{conn: conn} do ``` And that's where the connection comes from! At first, the testing structure does come with a bit of indirection, but this indirection pays off as our test suite grows, since it allows us to cut down the amount of boilerplate. ## View tests The other test files in our application are responsible for testing our views. The error view test case, `test/hello_web/controllers/error_html_test.exs`, illustrates a few interesting things of its own. ```elixir defmodule HelloWeb.ErrorHTMLTest do use HelloWeb.ConnCase, async: true # Bring render_to_string/4 for testing custom views import Phoenix.Template test "renders 404.html" do assert render_to_string(HelloWeb.ErrorHTML, "404", "html", []) == "Not Found" end test "renders 500.html" do assert render_to_string(HelloWeb.ErrorHTML, "500", "html", []) == "Internal Server Error" end end ``` `HelloWeb.ErrorHTMLTest` sets `async: true` which means that this test case will be run in parallel with other test cases. While individual tests within the case still run serially, this can greatly increase overall test speeds. It also imports `Phoenix.Template` in order to use the `render_to_string/4` function. With that, all the assertions can be simple string equality tests. ## Running tests per directory/file Now that we have an idea what our tests are doing, let's look at different ways to run them. As we saw near the beginning of this guide, we can run our entire suite of tests with `mix test`. ```console $ mix test .... Finished in 0.2 seconds 5 tests, 0 failures Randomized with seed 540755 ``` If we would like to run all the tests in a given directory, `test/hello_web/controllers` for instance, we can pass the path to that directory to `mix test`. ```console $ mix test test/hello_web/controllers/ . Finished in 0.2 seconds 5 tests, 0 failures Randomized with seed 652376 ``` In order to run all the tests in a specific file, we can pass the path to that file into `mix test`. ```console $ mix test test/hello_web/controllers/error_html_test.exs ... Finished in 0.2 seconds 2 tests, 0 failures Randomized with seed 220535 ``` And we can run a single test in a file by appending a colon and a line number to the filename. Let's say we only wanted to run the test for the way `HelloWeb.ErrorHTML` renders `500.html`. The test begins on line 11 of the file, so this is how we would do it. ```console $ mix test test/hello_web/controllers/error_html_test.exs:11 Including tags: [line: "11"] Excluding tags: [:test] . Finished in 0.1 seconds 2 tests, 0 failures, 1 excluded Randomized with seed 288117 ``` We chose to run this specifying the first line of the test, but actually, any line of that test will do. These line numbers would all work - `:11`, `:12`, or `:13`. ## Running tests using tags ExUnit allows us to tag our tests individually or for the whole module. We can then choose to run only the tests with a specific tag, or we can exclude tests with that tag and run everything else. Let's experiment with how this works. First, we'll add a `@moduletag` to `test/hello_web/controllers/error_html_test.exs`. ```elixir defmodule HelloWeb.ErrorHTMLTest do use HelloWeb.ConnCase, async: true @moduletag :error_view_case ... end ``` If we use only an atom for our module tag, ExUnit assumes that it has a value of `true`. We could also specify a different value if we wanted. ```elixir defmodule HelloWeb.ErrorHTMLTest do use HelloWeb.ConnCase, async: true @moduletag error_view_case: "some_interesting_value" ... end ``` For now, let's leave it as a simple atom `@moduletag :error_view_case`. We can run only the tests from the error view case by passing `--only error_view_case` into `mix test`. ```console $ mix test --only error_view_case Including tags: [:error_view_case] Excluding tags: [:test] ... Finished in 0.1 seconds 5 tests, 0 failures, 3 excluded Randomized with seed 125659 ``` > Note: ExUnit tells us exactly which tags it is including and excluding for each test run. If we look back to the previous section on running tests, we'll see that line numbers specified for individual tests are actually treated as tags. ```console $ mix test test/hello_web/controllers/error_html_test.exs:11 Including tags: [line: "11"] Excluding tags: [:test] . Finished in 0.2 seconds 2 tests, 0 failures, 1 excluded Randomized with seed 364723 ``` Specifying a value of `true` for `error_view_case` yields the same results. ```console $ mix test --only error_view_case:true Including tags: [error_view_case: "true"] Excluding tags: [:test] ... Finished in 0.1 seconds 5 tests, 0 failures, 3 excluded Randomized with seed 833356 ``` Specifying `false` as the value for `error_view_case`, however, will not run any tests because no tags in our system match `error_view_case: false`. ```console $ mix test --only error_view_case:false Including tags: [error_view_case: "false"] Excluding tags: [:test] Finished in 0.1 seconds 5 tests, 0 failures, 5 excluded Randomized with seed 622422 The --only option was given to "mix test" but no test executed ``` We can use the `--exclude` flag in a similar way. This will run all of the tests except those in the error view case. ```console $ mix test --exclude error_view_case Excluding tags: [:error_view_case] . Finished in 0.2 seconds 5 tests, 0 failures, 2 excluded Randomized with seed 682868 ``` Specifying values for a tag works the same way for `--exclude` as it does for `--only`. We can tag individual tests as well as full test cases. Let's tag a few tests in the error view case to see how this works. ```elixir defmodule HelloWeb.ErrorHTMLTest do use HelloWeb.ConnCase, async: true @moduletag :error_view_case # Bring render/4 and render_to_string/4 for testing custom views import Phoenix.Template @tag individual_test: "yup" test "renders 404.html" do assert render_to_string(HelloWeb.ErrorView, "404", "html", []) == "Not Found" end @tag individual_test: "nope" test "renders 500.html" do assert render_to_string(HelloWeb.ErrorView, "500", "html", []) == "Internal Server Error" end end ``` If we would like to run only tests tagged as `individual_test`, regardless of their value, this will work. ```console $ mix test --only individual_test Including tags: [:individual_test] Excluding tags: [:test] .. Finished in 0.1 seconds 5 tests, 0 failures, 3 excluded Randomized with seed 813729 ``` We can also specify a value and run only tests with that. ```console $ mix test --only individual_test:yup Including tags: [individual_test: "yup"] Excluding tags: [:test] . Finished in 0.1 seconds 5 tests, 0 failures, 4 excluded Randomized with seed 770938 ``` Similarly, we can run all tests except for those tagged with a given value. ```console $ mix test --exclude individual_test:nope Excluding tags: [individual_test: "nope"] ... Finished in 0.2 seconds 5 tests, 0 failures, 1 excluded Randomized with seed 539324 ``` We can be more specific and exclude all the tests from the error view case except the one tagged with `individual_test` that has the value "yup". ```console $ mix test --exclude error_view_case --include individual_test:yup Including tags: [individual_test: "yup"] Excluding tags: [:error_view_case] .. Finished in 0.2 seconds 5 tests, 0 failures, 1 excluded Randomized with seed 61472 ``` Finally, we can configure ExUnit to exclude tags by default. The default ExUnit configuration is done in the `test/test_helper.exs` file: ```elixir ExUnit.start(exclude: [error_view_case: true]) Ecto.Adapters.SQL.Sandbox.mode(Hello.Repo, :manual) ``` Now when we run `mix test`, it only runs the specs from our `page_controller_test.exs` and `error_json_test.exs`. ```console $ mix test Excluding tags: [error_view_case: true] . Finished in 0.2 seconds 5 tests, 0 failures, 2 excluded Randomized with seed 186055 ``` We can override this behavior with the `--include` flag, telling `mix test` to include tests tagged with `error_view_case`. ```console $ mix test --include error_view_case Including tags: [:error_view_case] Excluding tags: [error_view_case: true] .... Finished in 0.2 seconds 5 tests, 0 failures Randomized with seed 748424 ``` This technique can be very useful to control very long running tests, which you may only want to run in CI or in specific scenarios. ## Randomization Running tests in random order is a good way to ensure that our tests are truly isolated. If we notice that we get sporadic failures for a given test, it may be because a previous test changes the state of the system in ways that aren't cleaned up afterward, thereby affecting the tests which follow. Those failures might only present themselves if the tests are run in a specific order. ExUnit will randomize the order tests run in by default, using an integer to seed the randomization. If we notice that a specific random seed triggers our intermittent failure, we can re-run the tests with that same seed to reliably recreate that test sequence in order to help us figure out what the problem is. ```console $ mix test --seed 401472 .... Finished in 0.2 seconds 5 tests, 0 failures Randomized with seed 401472 ``` ## Concurrency and partitioning As we have seen, ExUnit allows developers to run tests concurrently. This allows developers to use all of the power in their machine to run their test suites as fast as possible. Couple this with Phoenix performance, most test suites compile and run in a fraction of the time compared to other frameworks. While developers usually have powerful machines available to them during development, this may not always be the case in your Continuous Integration servers. For this reason, ExUnit also supports out of the box test partitioning in test environments. If you open up your `config/test.exs`, you will find the database name set to: ```elixir database: "hello_test#{System.get_env("MIX_TEST_PARTITION")}", ``` By default, the `MIX_TEST_PARTITION` environment variable has no value, and therefore it has no effect. But in your CI server, you can, for example, split your test suite across machines by using four distinct commands: ```console $ MIX_TEST_PARTITION=1 mix test --partitions 4 $ MIX_TEST_PARTITION=2 mix test --partitions 4 $ MIX_TEST_PARTITION=3 mix test --partitions 4 $ MIX_TEST_PARTITION=4 mix test --partitions 4 ``` That's all you need to do and ExUnit and Phoenix will take care of all rest, including setting up the database for each distinct partition with a distinct name. ## Going further While ExUnit is a simple test framework, it provides a really flexible and robust test runner through the `mix test` command. We recommend you to run `mix help test` or [read the docs online](https://hexdocs.pm/mix/Mix.Tasks.Test.html) We've seen what Phoenix gives us with a newly generated app. Furthermore, whenever you generate a new resource, Phoenix will generate all appropriate tests for that resource too. For example, you can create a complete scaffold with schema, context, controllers, and views by running the following command at the root of your application: ```console $ mix phx.gen.html Blog Post posts title body:text * creating lib/hello_web/controllers/post_controller.ex * creating lib/hello_web/controllers/post_html/edit.html.heex * creating lib/hello_web/controllers/post_html/index.html.heex * creating lib/hello_web/controllers/post_html/new.html.heex * creating lib/hello_web/controllers/post_html/show.html.heex * creating lib/hello_web/controllers/post_html/post_form.html.heex * creating lib/hello_web/controllers/post_html.ex * creating test/hello_web/controllers/post_controller_test.exs * creating lib/hello/blog/post.ex * creating priv/repo/migrations/20211001233016_create_posts.exs * creating lib/hello/blog.ex * injecting lib/hello/blog.ex * creating test/hello/blog_test.exs * injecting test/hello/blog_test.exs * creating test/support/fixtures/blog_fixtures.ex * injecting test/support/fixtures/blog_fixtures.ex Add the resource to your browser scope in lib/demo_web/router.ex: resources "/posts", PostController Remember to update your repository by running migrations: $ mix ecto.migrate ``` Now let's follow the directions and add the new resources route to our `lib/hello_web/router.ex` file and run the migrations. When we run `mix test` again, we see that we now have twenty-one tests! ```console $ mix test ................ Finished in 0.1 seconds 21 tests, 0 failures Randomized with seed 537537 ``` At this point, we are at a great place to transition to the rest of the testing guides, in which we'll examine these tests in much more detail, and add some of our own. ================================================ FILE: guides/testing/testing_channels.md ================================================ # Testing Channels > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [Introduction to Testing guide](testing.html). > **Requirement**: This guide expects that you have gone through the [Channels guide](channels.html). In the Channels guide, we saw that a "Channel" is a layered system with different components. Given this, there would be cases when writing unit tests for our Channel functions may not be enough. We may want to verify that its different moving parts are working together as we expect. This integration testing would assure us that we correctly defined our channel route, the channel module, and its callbacks; and that the lower-level layers such as the PubSub and Transport are configured correctly and are working as intended. ## Generating channels As we progress through this guide, it would help to have a concrete example we could work off of. Phoenix comes with a Mix task for generating a basic channel and tests. These generated files serve as a good reference for writing channels and their corresponding tests. Let's go ahead and generate our Channel: ```console $ mix phx.gen.channel Room * creating lib/hello_web/channels/room_channel.ex * creating test/hello_web/channels/room_channel_test.exs * creating test/support/channel_case.ex The default socket handler - HelloWeb.UserSocket - was not found. Do you want to create it? [Yn] * creating lib/hello_web/channels/user_socket.ex * creating assets/js/user_socket.js Add the socket handler to your `lib/hello_web/endpoint.ex`, for example: socket "/socket", HelloWeb.UserSocket, websocket: true, longpoll: false For the front-end integration, you need to import the `user_socket.js` in your `assets/js/app.js` file: import "./user_socket.js" ``` This creates a channel, its test and instructs us to add a channel route in `lib/hello_web/channels/user_socket.ex`. It is important to add the channel route or our channel won't function at all! ## The ChannelCase Open up `test/hello_web/channels/room_channel_test.exs` and you will find this: ```elixir defmodule HelloWeb.RoomChannelTest do use HelloWeb.ChannelCase ``` Similar to `ConnCase` and `DataCase`, we now have a `ChannelCase`. All three of them have been generated for us when we started our Phoenix application. Let's take a look at it. Open up `test/support/channel_case.ex`: ```elixir defmodule HelloWeb.ChannelCase do use ExUnit.CaseTemplate using do quote do # Import conveniences for testing with channels import Phoenix.ChannelTest import HelloWeb.ChannelCase # The default endpoint for testing @endpoint HelloWeb.Endpoint end end setup _tags do Hello.DataCase.setup_sandbox(tags) :ok end end ``` It is very straight-forward. It sets up a case template that imports all of `Phoenix.ChannelTest` on use. In the `setup` block, it starts the SQL Sandbox, which we discussed in the [Testing contexts guide](testing_contexts.html). ## Subscribe and joining Now that we know that Phoenix provides with a custom Test Case just for channels and what it provides, we can move on to understanding the rest of `test/hello_web/channels/room_channel_test.exs`. First off, is the setup block: ```elixir setup do {:ok, _, socket} = HelloWeb.UserSocket |> socket("user_id", %{some: :assign}) |> subscribe_and_join(HelloWeb.RoomChannel, "room:lobby") %{socket: socket} end ``` The `setup` block sets up a `Phoenix.Socket` based on the `UserSocket` module, which you can find at `lib/hello_web/channels/user_socket.ex`. Then it says we want to subscribe and join the `RoomChannel`, accessible as `"room:lobby"` in the `UserSocket`. At the end of the test, we return the `%{socket: socket}` as metadata, so we can reuse it on every test. In a nutshell, `subscribe_and_join/3` emulates the client joining a channel and subscribes the test process to the given topic. This is a necessary step since clients need to join a channel before they can send and receive events on that channel. ## Testing a synchronous reply The first test block in our generated channel test looks like: ```elixir test "ping replies with status ok", %{socket: socket} do ref = push(socket, "ping", %{"hello" => "there"}) assert_reply ref, :ok, %{"hello" => "there"} end ``` This tests the following code in our `HelloWeb.RoomChannel`: ```elixir # Channels can be used in a request/response fashion # by sending replies to requests from the client def handle_in("ping", payload, socket) do {:reply, {:ok, payload}, socket} end ``` As is stated in the comment above, we see that a `reply` is synchronous since it mimics the request/response pattern we are familiar with in HTTP. This synchronous reply is best used when we only want to send an event back to the client when we are done processing the message on the server. For example, when we save something to the database and then send a message to the client only once that's done. In the `test "ping replies with status ok", %{socket: socket} do` line, we see that we have the map `%{socket: socket}`. This gives us access to the `socket` in the setup block. We emulate the client pushing a message to the channel with `push/3`. In the line `ref = push(socket, "ping", %{"hello" => "there"})`, we push the event `"ping"` with the payload `%{"hello" => "there"}` to the channel. This triggers the `handle_in/3` callback we have for the `"ping"` event in our channel. Note that we store the `ref` since we need that on the next line for asserting the reply. With `assert_reply ref, :ok, %{"hello" => "there"}`, we assert that the server sends a synchronous reply `:ok, %{"hello" => "there"}`. This is how we check that the `handle_in/3` callback for the `"ping"` was triggered. ### Testing a Broadcast It is common to receive messages from the client and broadcast to everyone subscribed to a current topic. This common pattern is simple to express in Phoenix and is one of the generated `handle_in/3` callbacks in our `HelloWeb.RoomChannel`. ```elixir def handle_in("shout", payload, socket) do broadcast(socket, "shout", payload) {:noreply, socket} end ``` Its corresponding test looks like: ```elixir test "shout broadcasts to room:lobby", %{socket: socket} do push(socket, "shout", %{"hello" => "all"}) assert_broadcast "shout", %{"hello" => "all"} end ``` We notice that we access the same `socket` that is from the setup block. How handy! We also do the same `push/3` as we did in the synchronous reply test. So we `push` the `"shout"` event with the payload `%{"hello" => "all"}`. Since the `handle_in/3` callback for the `"shout"` event just broadcasts the same event and payload, all subscribers in the `"room:lobby"` should receive the message. To check that, we do `assert_broadcast "shout", %{"hello" => "all"}`. **NOTE:** `assert_broadcast/3` tests that the message was broadcast in the PubSub system. For testing if a client receives a message, use `assert_push/3`. ### Testing an asynchronous push from the server The last test in our `HelloWeb.RoomChannelTest` verifies that broadcasts from the server are pushed to the client. Unlike the previous tests discussed, we are indirectly testing that the channel's `handle_out/3` callback is triggered. By default, `handle_out/3` is implemented for us and simply pushes the message on to the client. Since the `handle_out/3` event is only triggered when we call `broadcast/3` from our channel, we will need to emulate that in our test. We do that by calling `broadcast_from` or `broadcast_from!`. Both serve the same purpose with the only difference of `broadcast_from!` raising an error when broadcast fails. The line `broadcast_from!(socket, "broadcast", %{"some" => "data"})` will trigger the `handle_out/3` callback which pushes the same event and payload back to the client. To test this, we do `assert_push "broadcast", %{"some" => "data"}`. That's it. Now you are ready to develop and fully test real-time applications. To learn more about other functionality provided when testing channels, check out the documentation for [`Phoenix.ChannelTest`](https://hexdocs.pm/phoenix/Phoenix.ChannelTest.html). ================================================ FILE: guides/testing/testing_contexts.md ================================================ # Testing Contexts > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [Introduction to Testing guide](testing.html). > **Requirement**: This guide expects that you have gone through the [Contexts guides](contexts.html). At the end of the Introduction to Testing guide, we generated an HTML resource for posts using the following command: ```console $ mix phx.gen.html Blog Post posts title body:text ``` This gave us a number of modules for free, including a Blog context and a Post schema, alongside their respective test files. As we have learned in the Context guide, the Blog context is simply a module with functions to a particular area of our business domain, while Post schema maps to a particular table in our database. In this guide, we are going to explore the tests generated for our contexts and schemas. Before we do anything else, let's run `mix test` to make sure our test suite runs cleanly. ```console $ mix test ................ Finished in 0.6 seconds 21 tests, 0 failures Randomized with seed 638414 ``` Great. We've got twenty-one tests and they are all passing! ## Testing posts If you open up `test/hello/blog_test.exs`, you will see a file with the following: ```elixir defmodule Hello.BlogTest do use Hello.DataCase alias Hello.Blog describe "posts" do alias Hello.Blog.Post import Hello.BlogFixtures @invalid_attrs %{body: nil, title: nil} test "list_posts/0 returns all posts" do post = post_fixture() assert Blog.list_posts() == [post] end ... ``` As the top of the file we import `Hello.DataCase`, which as we will see soon, it is similar to `HelloWeb.ConnCase`. While `HelloWeb.ConnCase` sets up helpers for working with connections, which is useful when testing controllers and views, `Hello.DataCase` provides functionality for working with contexts and schemas. Next, we define an alias, so we can refer to `Hello.Blog` simply as `Blog`. Then we start a `describe "posts"` block. A `describe` block is a feature in ExUnit that allows us to group similar tests. The reason why we have grouped all post related tests together is because contexts in Phoenix are capable of grouping multiple schemas together. For example, if we ran this command: ```console $ mix phx.gen.html Blog Comment comments post_id:references:posts body:text ``` We will get a bunch of new functions in the `Hello.Blog` context, plus a whole new `describe "comments"` block in our test file. The tests defined for our context are very straight-forward. They call the functions in our context and assert on their results. As you can see, some of those tests even create entries in the database: ```elixir test "create_post/1 with valid data creates a post" do valid_attrs = %{body: "some body", title: "some title"} assert {:ok, %Post{} = post} = Blog.create_post(valid_attrs) assert post.body == "some body" assert post.title == "some title" end ``` At this point, you may wonder: how can Phoenix make sure the data created in one of the tests do not affect other tests? We are glad you asked. To answer this question, let's talk about the `DataCase`. ## The DataCase If you open up `test/support/data_case.ex`, you will find the following: ```elixir defmodule Hello.DataCase do use ExUnit.CaseTemplate using do quote do alias Hello.Repo import Ecto import Ecto.Changeset import Ecto.Query import Hello.DataCase end end setup tags do Hello.DataCase.setup_sandbox(tags) :ok end def setup_sandbox(tags) do pid = Ecto.Adapters.SQL.Sandbox.start_owner!(Hello.Repo, shared: not tags[:async]) on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end) end def errors_on(changeset) do ... end end ``` `Hello.DataCase` is another `ExUnit.CaseTemplate`. In the `using` block, we can see all of the aliases and imports `DataCase` brings into our tests. The `setup` chunk for `DataCase` is very similar to the one from `ConnCase`. As we can see, most of the `setup` block revolves around setting up a SQL Sandbox. The SQL Sandbox is precisely what allows our tests to write to the database without affecting any of the other tests. In a nutshell, at the beginning of every test, we start a transaction in the database. When the test is over, we automatically rollback the transaction, effectively erasing all of the data created in the test. Furthermore, the SQL Sandbox allows multiple tests to run concurrently, even if they talk to the database. This feature is provided for PostgreSQL databases and it can be used to further speed up your contexts and controllers tests by adding a `async: true` flag when using them: ```elixir use Hello.DataCase, async: true ``` There are some considerations you need to have in mind when running asynchronous tests with the sandbox, so please refer to the [`Ecto.Adapters.SQL.Sandbox`](https://hexdocs.pm/ecto_sql/Ecto.Adapters.SQL.Sandbox.html) for more information. Finally, at the end of the `DataCase` module we can find a function named `errors_on` with some examples of how to use it. This function is used for testing any validation we may want to add to our schemas. Let's give it a try by adding our own validations and then testing them. ## Testing schemas When we generate our HTML Post resource, Phoenix generated a Blog context and a Post schema. It generated a test file for the context, but no test file for the schema. However, this doesn't mean we don't need to test the schema, it just means we did not have to test the schema so far. You may be wondering then: when do we test the context directly and when do we test the schema directly? The answer to this question is the same answer to the question of when do we add code to a context and when do we add it to the schema? The general guideline is to keep all side-effect free code in the schema. In other words, if you are simply working with data structures, schemas and changesets, put it in the schema. The context will typically have the code that creates and updates schemas and then write them to a database or an API. We'll be adding additional validations to the schema module, so that's a great opportunity to write some schema specific tests. Open up `lib/hello/blog/post.ex` and add the following validation to `def changeset`: ```elixir def changeset(post, attrs) do post |> cast(attrs, [:title, :body]) |> validate_required([:title, :body]) |> validate_length(:title, min: 2) end ``` The new validation says the title needs to have at least 2 characters. Let's write a test for this. Create a new file at `test/hello/blog/post_test.exs` with this: ```elixir defmodule Hello.Blog.PostTest do use Hello.DataCase, async: true alias Hello.Blog.Post test "title must be at least two characters long" do changeset = Post.changeset(%Post{}, %{title: "I"}) assert %{title: ["should be at least 2 character(s)"]} = errors_on(changeset) end end ``` And that's it. As our business domain grows, we have well-defined places to test our contexts and schemas. ================================================ FILE: guides/testing/testing_controllers.md ================================================ # Testing Controllers > **Requirement**: This guide expects that you have gone through the [introductory guides](installation.html) and got a Phoenix application [up and running](up_and_running.html). > **Requirement**: This guide expects that you have gone through the [Introduction to Testing guide](testing.html). At the end of the Introduction to Testing guide, we generated an HTML resource for posts using the following command: ```console $ mix phx.gen.html Blog Post posts title body:text ``` This gave us a number of modules for free, including a PostController and the associated tests. We are going to explore those tests to learn more about testing controllers in general. At the end of the guide, we will generate a JSON resource, and explore how our API tests look like. ## HTML controller tests If you open up `test/hello_web/controllers/post_controller_test.exs`, you will find the following: ```elixir defmodule HelloWeb.PostControllerTest do use HelloWeb.ConnCase import Hello.BlogFixtures @create_attrs %{body: "some body", title: "some title"} @update_attrs %{body: "some updated body", title: "some updated title"} @invalid_attrs %{body: nil, title: nil} describe "index" do test "lists all posts", %{conn: conn} do conn = get(conn, ~p"/posts") assert html_response(conn, 200) =~ "Listing Posts" end end ... ``` Similar to the `PageControllerTest` that ships with our application, this controller tests uses `use HelloWeb.ConnCase` to setup the testing structure. Then, as usual, it defines some aliases, some module attributes to use throughout testing, and then it starts a series of `describe` blocks, each of them to test a different controller action. ### The index action The first describe block is for the `index` action. The action itself is implemented like this in `lib/hello_web/controllers/post_controller.ex`: ```elixir def index(conn, _params) do posts = Blog.list_posts() render(conn, :index, posts: posts) end ``` It gets all posts and renders the "index.html" template. The template can be found in `lib/hello_web/controllers/post_html/index.html.heex`. The test looks like this: ```elixir describe "index" do test "lists all posts", %{conn: conn} do conn = get(conn, ~p"/posts") assert html_response(conn, 200) =~ "Listing Posts" end end ``` The test for the `index` page is quite straight-forward. It uses the `get/2` helper to make a request to the `"/posts"` page, which is verified against our router in the test thanks to `~p`, then we assert we got a successful HTML response and match on its contents. ### The create action The next test we will look at is the one for the `create` action. The `create` action implementation is this: ```elixir def create(conn, %{"post" => post_params}) do case Blog.create_post(post_params) do {:ok, post} -> conn |> put_flash(:info, "Post created successfully.") |> redirect(to: ~p"/posts/#{post}") {:error, %Ecto.Changeset{} = changeset} -> render(conn, :new, changeset: changeset) end end ``` Since there are two possible outcomes for the `create`, we will have at least two tests: ```elixir describe "create post" do test "redirects to show when data is valid", %{conn: conn} do conn = post(conn, ~p"/posts", post: @create_attrs) assert %{id: id} = redirected_params(conn) assert redirected_to(conn) == ~p"/posts/#{id}" conn = get(conn, ~p"/posts/#{id}") assert html_response(conn, 200) =~ "Post #{id}" end test "renders errors when data is invalid", %{conn: conn} do conn = post(conn, ~p"/posts", post: @invalid_attrs) assert html_response(conn, 200) =~ "New Post" end end ``` The first test starts with a `post/2` request. That's because once the form in the `/posts/new` page is submitted, it becomes a POST request to the create action. Because we have supplied valid attributes, the post should have been successfully created and we should have redirected to the show action of the new post. This new page will have an address like `/posts/ID`, where ID is the identifier of the post in the database. We then use `redirected_params(conn)` to get the ID of the post and then match that we indeed redirected to the show action. Finally, we do a `get` request to the page we redirected to, allowing us to verify that the post was indeed created. For the second test, we simply test the failure scenario. If any invalid attribute is given, it should re-render the "New Post" page. One common question is: how many failure scenarios do you test at the controller level? For example, in the [Testing Contexts](testing_contexts.html) guide, we introduced a validation to the `title` field of the post: ```elixir def changeset(post, attrs) do post |> cast(attrs, [:title, :body]) |> validate_required([:title, :body]) |> validate_length(:title, min: 2) end ``` In other words, creating a post can fail for the following reasons: * the title is missing * the body is missing * the title is present but is less than 2 characters Should we test all of these possible outcomes in our controller tests? The answer is no. All of the different rules and outcomes should be verified in your context and schema tests. The controller works as the integration layer. In the controller tests we simply want to verify, in broad strokes, that we handle both success and failure scenarios. The test for `update` follows a similar structure as `create`, so let's skip to the `delete` test. ### The delete action The `delete` action looks like this: ```elixir def delete(conn, %{"id" => id}) do post = Blog.get_post!(id) {:ok, _post} = Blog.delete_post(post) conn |> put_flash(:info, "Post deleted successfully.") |> redirect(to: ~p"/posts") end ``` The test is written like this: ```elixir describe "delete post" do setup [:create_post] test "deletes chosen post", %{conn: conn, post: post} do conn = delete(conn, ~p"/posts/#{post}") assert redirected_to(conn) == ~p"/posts" assert_error_sent 404, fn -> get(conn, ~p"/posts/#{post}") end end end defp create_post(_) do post = post_fixture() %{post: post} end ``` First of all, `setup` is used to declare that the `create_post` function should run before every test in this `describe` block. The `create_post` function simply creates a post and stores it in the test metadata. This allows us to, in the first line of the test, match on both the post and the connection: ```elixir test "deletes chosen post", %{conn: conn, post: post} do ``` The test uses `delete/2` to delete the post and then asserts that we redirected to the index page. Finally, we check that it is no longer possible to access the show page of the deleted post: ```elixir assert_error_sent 404, fn -> get(conn, ~p"/posts/#{post}") end ``` `assert_error_sent` is a testing helper provided by `Phoenix.ConnTest`. In this case, it verifies that: 1. An exception was raised 2. The exception has a status code equivalent to 404 (which stands for Not Found) This pretty much mimics how Phoenix handles exceptions. For example, when we access `/posts/12345` where `12345` is an ID that does not exist, we will invoke our `show` action: ```elixir def show(conn, %{"id" => id}) do post = Blog.get_post!(id) render(conn, :show, post: post) end ``` When an unknown post ID is given to `Blog.get_post!/1`, it raises an `Ecto.NotFoundError`. If your application raises any exception during a web request, Phoenix translates those requests into proper HTTP response codes. In this case, 404. We could, for example, have written this test as: ```elixir assert_raise Ecto.NotFoundError, fn -> get(conn, ~p"/posts/#{post}") end ``` However, you may prefer the implementation Phoenix generates by default as it ignores the specific details of the failure, and instead verifies what the browser would actually receive. The tests for `new`, `edit`, and `show` actions are simpler variations of the tests we have seen so far. You can check the action implementation and their respective tests yourself. Now we are ready to move to JSON controller tests. ## JSON controller tests So far we have been working with a generated HTML resource. However, let's take a look at how our tests look like when we generate a JSON resource. First of all, run this command: ```console $ mix phx.gen.json News Article articles title body ``` We chose a very similar concept to the Blog context <-> Post schema, except we are using a different name, so we can study these concepts in isolation. After you run the command above, do not forget to follow the final steps output by the generator. Once all is done, we should run `mix test` and now have 35 passing tests: ```console $ mix test ................ Finished in 0.6 seconds 35 tests, 0 failures Randomized with seed 618478 ``` You may have noticed that this time the scaffold controller has generated fewer tests. Previously it generated 16 (we went from 5 to 21) and now it generated 14 (we went from 21 to 35). That's because JSON APIs do not need to expose the `new` and `edit` actions. We can see this is the case in the resource we have added to the router at the end of the `mix phx.gen.json` command: ```elixir resources "/articles", ArticleController, except: [:new, :edit] ``` `new` and `edit` are only necessary for HTML because they basically exist to assist users in creating and updating resources. Besides having less actions, we will notice the controller and view tests and implementations for JSON are drastically different from the HTML ones. The only thing that is pretty much the same between HTML and JSON is the contexts and the schema, which, once you think about it, it makes total sense. After all, your business logic should remain the same, regardless if you are exposing it as HTML or JSON. With the differences in hand, let's take a look at the controller tests. ### The index action Open up `test/hello_web/controllers/article_controller_test.exs`. The initial structure is quite similar to `post_controller_test.exs`. So let's take a look at the tests for the `index` action. The `index` action itself is implemented in `lib/hello_web/controllers/article_controller.ex` like this: ```elixir def index(conn, _params) do articles = News.list_articles() render(conn, :index, articles: articles) end ``` The action gets all articles and renders the index template. Since we are talking about JSON, we don't have a `index.json.heex` template. Instead, the code that converts `articles` into JSON can be found directly in the ArticleJSON module, defined at `lib/hello_web/controllers/article_json.ex` like this: ```elixir defmodule HelloWeb.ArticleJSON do alias Hello.News.Article def index(%{articles: articles}) do %{data: for(article <- articles, do: data(article))} end def show(%{article: article}) do %{data: data(article)} end defp data(%Article{} = article) do %{ id: article.id, title: article.title, body: article.body } end end ``` Since a controller render is a regular function call, we don't need any extra features to render JSON. We simply define functions for our `index` and `show` actions that return the map of JSON for articles. Let's take a look at the test for the `index` action then: ```elixir describe "index" do test "lists all articles", %{conn: conn} do conn = get(conn, ~p"/api/articles") assert json_response(conn, 200)["data"] == [] end end ``` It simply accesses the `index` path, asserts we got a JSON response with status 200 and that it contains a "data" key with an empty list, as we have no articles to return. That was quite boring. Let's look at something more interesting. ### The `create` action The `create` action is defined like this: ```elixir def create(conn, %{"article" => article_params}) do with {:ok, %Article{} = article} <- News.create_article(article_params) do conn |> put_status(:created) |> put_resp_header("location", ~p"/api/articles/#{article}") |> render(:show, article: article) end end ``` As we can see, it checks if an article could be created. If so, it sets the status code to `:created` (which translates to 201), it sets a "location" header with the location of the article, and then renders "show.json" with the article. This is precisely what the first test for the `create` action verifies: ```elixir describe "create article" do test "renders article when data is valid", %{conn: conn} do conn = post(conn, ~p"/articles", article: @create_attrs) assert %{"id" => id} = json_response(conn, 201)["data"] conn = get(conn, ~p"/api/articles/#{id}") assert %{ "id" => ^id, "body" => "some body", "title" => "some title" } = json_response(conn, 200)["data"] end ``` The test uses `post/2` to create a new article and then we verify that the article returned a JSON response, with status 201, and that it had a "data" key in it. We pattern match the "data" on `%{"id" => id}`, which allows us to extract the ID of the new article. Then we perform a `get/2` request on the `show` route and verify that the article was successfully created. Inside `describe "create article"`, we will find another test, which handles the failure scenario. Can you spot the failure scenario in the `create` action? Let's recap it: ```elixir def create(conn, %{"article" => article_params}) do with {:ok, %Article{} = article} <- News.create_article(article_params) do ``` The `with` special form that ships as part of Elixir allows us to check explicitly for the happy paths. In this case, we are interested only in the scenarios where `News.create_article(article_params)` returns `{:ok, article}`, if it returns anything else, the other value will simply be returned directly and none of the contents inside the `do/end` block will be executed. In other words, if `News.create_article/1` returns `{:error, changeset}`, we will simply return `{:error, changeset}` from the action. However, this introduces an issue. Our actions do not know how to handle the `{:error, changeset}` result by default. Luckily, we can teach Phoenix Controllers to handle it with the Action Fallback controller. At the top of `ArticleController`, you will find: ```elixir action_fallback HelloWeb.FallbackController ``` This line says: if any action does not return a `%Plug.Conn{}`, we want to invoke `FallbackController` with the result. You will find `HelloWeb.FallbackController` at `lib/hello_web/controllers/fallback_controller.ex` and it looks like this: ```elixir defmodule HelloWeb.FallbackController do use HelloWeb, :controller def call(conn, {:error, %Ecto.Changeset{} = changeset}) do conn |> put_status(:unprocessable_entity) |> put_view(json: HelloWeb.ChangesetJSON) |> render(:error, changeset: changeset) end def call(conn, {:error, :not_found}) do conn |> put_status(:not_found) |> put_view(html: HelloWeb.ErrorHTML, json: HelloWeb.ErrorJSON) |> render(:"404") end end ``` You can see how the first clause of the `call/2` function handles the `{:error, changeset}` case, setting the status code to unprocessable entity (422), and then rendering "error.json" from the changeset view with the failed changeset. With this in mind, let's look at our second test for `create`: ```elixir test "renders errors when data is invalid", %{conn: conn} do conn = post(conn, ~p"/api/articles", article: @invalid_attrs) assert json_response(conn, 422)["errors"] != %{} end ``` It simply posts to the `create` path with invalid parameters. This makes it return a JSON response, with status code 422, and a response with a non-empty "errors" key. The `action_fallback` can be extremely useful to reduce boilerplate when designing APIs. You can learn more about the "Action Fallback" in the [Controllers guide](controllers.html). ### The `delete` action Finally, the last action we will study is the `delete` action for JSON. Its implementation looks like this: ```elixir def delete(conn, %{"id" => id}) do article = News.get_article!(id) with {:ok, %Article{}} <- News.delete_article(article) do send_resp(conn, :no_content, "") end end ``` The new action simply attempts to delete the article and, if it succeeds, it returns an empty response with status code `:no_content` (204). The test looks like this: ```elixir describe "delete article" do setup [:create_article] test "deletes chosen article", %{conn: conn, article: article} do conn = delete(conn, ~p"/api/articles/#{article}") assert response(conn, 204) assert_error_sent 404, fn -> get(conn, ~p"/api/articles/#{article}") end end end defp create_article(_) do article = article_fixture() %{article: article} end ``` It setups a new article, then in the test it invokes the `delete` path to delete it, asserting on a 204 response, which is neither JSON nor HTML. Then it verifies that we can no longer access said article. That's all! Now that we understand how the scaffolded code and their tests work for both HTML and JSON APIs, we are prepared to move forward in building and maintaining our web applications! ================================================ FILE: installer/.gitignore ================================================ templates/phoenix-usage-rules/ ================================================ FILE: installer/README.md ================================================ ## mix phx.new Provides `phx.new` installer as an archive. To install from Hex, run: $ mix archive.install hex phx_new To build and install it locally, ensure any previous archive versions are removed: $ mix archive.uninstall phx_new Then run: $ cd installer $ MIX_ENV=prod mix do archive.build + archive.install ================================================ FILE: installer/lib/mix/tasks/local.phx.ex ================================================ defmodule Mix.Tasks.Local.Phx do use Mix.Task @shortdoc "Updates the Phoenix project generator locally" @moduledoc """ Updates the Phoenix project generator locally. $ mix local.phx Accepts the same command line options as `archive.install hex phx_new`. """ @impl true def run(args) do Mix.Task.run("archive.install", ["hex", "phx_new" | args]) end end ================================================ FILE: installer/lib/mix/tasks/phx.new.ecto.ex ================================================ defmodule Mix.Tasks.Phx.New.Ecto do @moduledoc """ Creates a new Ecto project within an umbrella project. This task is intended to create a bare Ecto project without web integration, which serves as a core application of your domain for web applications and your greater umbrella platform to integrate with. It expects the name of the project as an argument. $ cd my_umbrella/apps $ mix phx.new.ecto APP [--module MODULE] [--app APP] A project at the given APP directory will be created. The application name and module name will be retrieved from the application name, unless `--module` or `--app` is given. ## Options * `--app` - the name of the OTP application * `--module` - the name of the base module in the generated skeleton * `--database` - specify the database adapter for Ecto. One of: * `postgres` - via https://github.com/elixir-ecto/postgrex * `mysql` - via https://github.com/elixir-ecto/myxql * `mssql` - via https://github.com/livehelpnow/tds * `sqlite3` - via https://github.com/elixir-sqlite/ecto_sqlite3 Please check the driver docs for more information and requirements. Defaults to "postgres". * `--binary-id` - use `binary_id` as primary key type in Ecto schemas ## Examples $ mix phx.new.ecto hello_ecto Is equivalent to: $ mix phx.new.ecto hello_ecto --module HelloEcto """ @shortdoc "Creates a new Ecto project within an umbrella project" use Mix.Task @impl true def run([]) do Mix.Tasks.Help.run(["phx.new.ecto"]) end def run([path | _] = args) do unless Phx.New.Generator.in_umbrella?(path) do Mix.raise("The ecto task can only be run within an umbrella's apps directory") end Mix.Tasks.Phx.New.run(args ++ ["--no-assets", "--ecto"], Phx.New.Ecto, :app_path) end end ================================================ FILE: installer/lib/mix/tasks/phx.new.ex ================================================ defmodule Mix.Tasks.Phx.New do @moduledoc """ Creates a new Phoenix project. It expects the path of the project as an argument. $ mix phx.new PATH [--module MODULE] [--app APP] A project at the given PATH will be created. The application name and module name will be retrieved from the path, unless `--module` or `--app` is given. ## Options * `--umbrella` - generate an umbrella project, with one application for your domain, and a second application for the web interface. * `--app` - the name of the OTP application * `--module` - the name of the base module in the generated skeleton * `--database` - specify the database adapter for Ecto. One of: * `postgres` - via https://github.com/elixir-ecto/postgrex * `mysql` - via https://github.com/elixir-ecto/myxql * `mssql` - via https://github.com/livehelpnow/tds * `sqlite3` - via https://github.com/elixir-sqlite/ecto_sqlite3 Please check the driver docs for more information and requirements. Defaults to "postgres". * `--adapter` - specify the http adapter. One of: * `cowboy` - via https://github.com/elixir-plug/plug_cowboy * `bandit` - via https://github.com/mtrudel/bandit Please check the adapter docs for more information and requirements. Defaults to "bandit". * `--no-assets` - equivalent to `--no-esbuild` and `--no-tailwind` * `--no-dashboard` - do not include Phoenix.LiveDashboard * `--no-ecto` - do not generate Ecto files * `--no-esbuild` - do not include esbuild dependencies and assets. We do not recommend setting this option, unless for API only applications, as doing so requires you to manually add and track JavaScript dependencies * `--no-gettext` - do not generate gettext files * `--no-html` - do not generate HTML views * `--no-live` - comment out LiveView socket setup in your Endpoint and assets/js/app.js. Automatically disabled if --no-html is given * `--no-mailer` - do not generate Swoosh mailer files * `--no-tailwind` - do not include tailwind dependencies and assets. The generated markup will still include Tailwind CSS classes, those are left-in as reference for the subsequent styling of your layout and components * `--binary-id` - use `binary_id` as primary key type in Ecto schemas * `--verbose` - use verbose output * `-v`, `--version` - prints the Phoenix installer version * `--no-version-check` - skip the version check for the latest phx_new version * `--no-agents-md` - do not generate an `AGENTS.md` file When passing the `--no-ecto` flag, Phoenix generators such as `phx.gen.html`, `phx.gen.json`, `phx.gen.live`, and `phx.gen.context` may no longer work as expected as they generate context files that rely on Ecto for the database access. In those cases, you can pass the `--no-context` flag to generate most of the HTML and JSON files but skip the context, allowing you to fill in the blanks as desired. Similarly, if `--no-html` is given, the files generated by `phx.gen.html` will no longer work, as important HTML components will be missing. ## Installation `mix phx.new` by default prompts you to fetch and install your dependencies. You can enable this behaviour by passing the `--install` flag or disable it with the `--no-install` flag. ## Examples $ mix phx.new hello_world Is equivalent to: $ mix phx.new hello_world --module HelloWorld Or without the HTML and JS bits (useful for APIs): $ mix phx.new ~/Workspace/hello_world --no-html --no-assets As an umbrella: $ mix phx.new hello --umbrella Would generate the following directory structure and modules: ```text hello_umbrella/ Hello.Umbrella apps/ hello/ Hello hello_web/ HelloWeb ``` You can read more about umbrella projects in the [mix documentation](https://hexdocs.pm/mix/Mix.Project.html#module-umbrella-projects) ## `PHX_NEW_CACHE_DIR` In rare cases, it may be useful to copy the build from a previously cached build. To do this, set the `PHX_NEW_CACHE_DIR` environment variable before running `mix phx.new`. For example, you could generate a cache by running: ```shell mix phx.new mycache --no-install && cd mycache \ && mix deps.get && mix deps.compile && mix assets.setup \ && rm -rf assets config lib priv test mix.exs README.md ``` Your cached build directory should contain: _build deps mix.lock Then you could run: ```shell PHX_NEW_CACHE_DIR=/path/to/mycache mix phx.new myapp ``` The entire cache directory will be copied to the new project, replacing any existing files where conflicts exist. """ use Mix.Task alias Phx.New.{Generator, Project, Single, Umbrella, Web, Ecto} @version Mix.Project.config()[:version] @shortdoc "Creates a new Phoenix v#{@version} application" @switches [ dev: :boolean, assets: :boolean, esbuild: :boolean, tailwind: :boolean, ecto: :boolean, app: :string, module: :string, web_module: :string, database: :string, binary_id: :boolean, html: :boolean, gettext: :boolean, umbrella: :boolean, verbose: :boolean, live: :boolean, dashboard: :boolean, install: :boolean, prefix: :string, mailer: :boolean, adapter: :string, inside_docker_env: :boolean, from_elixir_install: :boolean, version_check: :boolean, agents_md: :boolean ] @reserved_app_names ~w(server table) @impl true def run([version]) when version in ~w(-v --version) do Mix.shell().info("Phoenix installer v#{@version}") end def run(argv) do elixir_version_check!() {opts, argv} = OptionParser.parse!(argv, strict: @switches) version_task = if Keyword.get(opts, :version_check, true) do get_latest_version("phx_new") end result = case {opts, argv} do {_opts, []} -> Mix.Tasks.Help.run(["phx.new"]) {opts, [base_path | _]} -> if opts[:umbrella] do generate(base_path, Umbrella, :project_path, opts) else generate(base_path, Single, :base_path, opts) end end if version_task do try do # if we get anything else than a `Version`, we'll get a MatchError # and fail silently %Version{} = latest_version = Task.await(version_task, 3_000) maybe_warn_outdated(latest_version) rescue _ -> :ok catch :exit, _ -> :ok end end result end @doc false def run(argv, generator, path) do elixir_version_check!() case OptionParser.parse!(argv, strict: @switches) do {_opts, []} -> Mix.Tasks.Help.run(["phx.new"]) {opts, [base_path | _]} -> generate(base_path, generator, path, opts) end end defp generate(base_path, generator, path, opts) do base_path |> Project.new(opts) |> generator.prepare_project() |> Generator.put_binding() |> validate_project(path) |> generator.generate() |> maybe_copy_cached_build(path) |> maybe_init_git(path) |> maybe_prompt_to_install_deps(generator, path) end defp validate_project(%Project{opts: opts} = project, path) do check_app_name!(project.app, !!opts[:app]) check_directory_existence!(Map.fetch!(project, path)) check_module_name_validity!(project.root_mod) check_module_name_availability!(project.root_mod) project end defp maybe_prompt_to_install_deps(%Project{} = project, generator, path_key) do # we can skip the install deps setup, even with --install, because we already copied deps if project.cached_build_path do project else prompt_to_install_deps(project, generator, path_key) end end defp prompt_to_install_deps(%Project{} = project, generator, path_key) do path = Map.fetch!(project, path_key) install? = Keyword.get_lazy(project.opts, :install, fn -> Mix.shell().yes?("\nFetch and install dependencies?") end) cd_step = ["$ cd #{relative_app_path(path)}"] maybe_cd(path, fn -> mix_step = install_mix(project, install?) if mix_step == [] do builders = Keyword.fetch!(project.binding, :asset_builders) if builders != [] do Mix.shell().info([:green, "* running ", :reset, "mix assets.setup"]) # First compile only builders so we can install in parallel # TODO: Once we require Erlang/OTP 28, jason may no longer be required cmd(project, "mix deps.compile jason #{Enum.join(builders, " ")}", log: false) end tasks = Enum.map(builders, fn builder -> cmd = "mix do loadpaths --no-compile --no-listeners + #{builder}.install" Task.async(fn -> cmd(project, cmd, log: false, cd: project.web_path) end) end) cmd(project, "mix deps.compile") Task.await_many(tasks, :infinity) end print_missing_steps(cd_step ++ mix_step) if Project.ecto?(project) do print_ecto_info(generator) end if path_key == :web_path do Mix.shell().info(""" Your web app requires a PubSub server to be running. The PubSub server is typically defined in a `mix phx.new.ecto` app. If you don't plan to define an Ecto app, you must explicitly start the PubSub in your supervision tree as: {Phoenix.PubSub, name: #{inspect(project.app_mod)}.PubSub} """) end print_mix_info(generator) end) end defp maybe_cd(path, func), do: path && File.cd!(path, func) defp install_mix(project, install?) do if install? do cmd(project, "mix deps.get") else ["$ mix deps.get"] end end defp print_missing_steps(steps) do Mix.shell().info(""" We are almost there! The following steps are missing: #{Enum.join(steps, "\n ")} """) end defp print_ecto_info(Web), do: :ok defp print_ecto_info(_gen) do Mix.shell().info(""" Then configure your database in config/dev.exs and run: $ mix ecto.create """) end defp print_mix_info(Ecto) do Mix.shell().info(""" You can run your app inside IEx (Interactive Elixir) as: $ iex -S mix """) end defp print_mix_info(_gen) do Mix.shell().info(""" Start your Phoenix app with: $ mix phx.server You can also run your app inside IEx (Interactive Elixir) as: $ iex -S mix phx.server """) end defp relative_app_path(path) do case Path.relative_to_cwd(path) do ^path -> Path.basename(path) rel -> rel end end ## Helpers defp cmd(%Project{} = project, cmd, opts \\ []) do {log?, opts} = Keyword.pop(opts, :log, true) if log? do Mix.shell().info([:green, "* running ", :reset, cmd]) end case Mix.shell().cmd(cmd, opts ++ cmd_opts(project)) do 0 -> [] _ -> ["$ #{cmd}"] end end defp cmd_opts(%Project{} = project) do if Project.verbose?(project) do [] else [quiet: true] end end defp check_app_name!(name, from_app_flag) do with :ok <- validate_not_reserved(name), :ok <- validate_app_name_format(name, from_app_flag) do :ok end end defp validate_not_reserved(name) when name in @reserved_app_names do Mix.raise("Application name cannot be #{inspect(name)} as it is reserved") end defp validate_not_reserved(_name), do: :ok defp validate_app_name_format(name, from_app_flag) do if name =~ ~r/^[a-z][a-z0-9_]*$/ do :ok else extra = if !from_app_flag do ". The application name is inferred from the path, if you'd like to " <> "explicitly name the application then use the `--app APP` option." else "" end Mix.raise( "Application name must start with a letter and have only lowercase " <> "letters, numbers and underscore, got: #{inspect(name)}" <> extra ) end end defp check_module_name_validity!(name) do unless inspect(name) =~ Regex.recompile!(~r/^[A-Z]\w*(\.[A-Z]\w*)*$/) do Mix.raise( "Module name must be a valid Elixir alias (for example: Foo.Bar), got: #{inspect(name)}" ) end end defp check_module_name_availability!(name) do [name] |> Module.concat() |> Module.split() |> Enum.reduce([], fn name, acc -> mod = Module.concat([Elixir, name | acc]) if Code.ensure_loaded?(mod) do Mix.raise("Module name #{inspect(mod)} is already taken, please choose another name") else [name | acc] end end) end defp check_directory_existence!(path) do if File.dir?(path) and not Mix.shell().yes?( "The directory #{path} already exists. Are you sure you want to continue?" ) do Mix.raise("Please select another directory for installation.") end end defp elixir_version_check! do unless Version.match?(System.version(), "~> 1.15") do Mix.raise( "Phoenix v#{@version} requires at least Elixir v1.15\n " <> "You have #{System.version()}. Please update accordingly" ) end end defp git_available? do case System.find_executable("git") do nil -> false _path -> true end end defp inside_git_repo?(path) do case System.cmd("git", ["status"], cd: path, stderr_to_stdout: true) do {_output, 0} -> true _ -> false end rescue _ -> false end defp maybe_init_git(%Project{} = project, path_key) do project_path = Map.fetch!(project, path_key) if git_available?() and not inside_git_repo?(project_path) do Mix.shell().info([:green, "* initializing git repository", :reset]) case System.cmd("git", ["init"], cd: project_path) do {_output, 0} -> :ok {output, _} -> Mix.shell().error("Failed to initialize git repository: #{output}") end end project end defp maybe_copy_cached_build(%Project{} = project, path_key) do project_path = Map.fetch!(project, path_key) case System.fetch_env("PHX_NEW_CACHE_DIR") do {:ok, cache_dir} -> copy_cached_build(%{project_path: project_path, cache_dir: cache_dir}) %{project | cached_build_path: cache_dir} :error -> project end end defp copy_cached_build(%{project_path: project_path, cache_dir: cache_dir}) do if File.exists?(cache_dir) do Mix.shell().info("Copying cached build from #{cache_dir}") System.cmd("cp", ["-Rp", Path.join(cache_dir, "."), project_path]) end end defp maybe_warn_outdated(latest_version) do if Version.compare(@version, latest_version) == :lt do Mix.shell().info([ :yellow, "A new version of phx.new is available:", :green, " v#{latest_version}", :reset, ".", "\n", "You are currently running ", :red, "v#{@version}", :reset, ".\n", "To update, run:\n\n", " $ mix local.phx\n" ]) end end # we need to parse JSON, so we only check for new versions on Elixir 1.18+ if Version.match?(System.version(), "~> 1.18") do defp get_latest_version(package) do Task.async(fn -> # ignore any errors to not prevent the generators from running # due to any issues while checking the version try do with {:ok, package} <- get_package(package) do versions = for release <- package["releases"], version = Version.parse!(release["version"]), # ignore pre-releases like release candidates, etc. version.pre == [] do version end Enum.max(versions, Version) end rescue e -> {:error, e} catch :exit, _ -> {:error, :exit} end end) end defp get_package(name) do http_options = [ ssl: [ verify: :verify_peer, cacerts: :public_key.cacerts_get(), depth: 2, customize_hostname_check: [ match_fun: :public_key.pkix_verify_hostname_match_fun(:https) ], versions: [:"tlsv1.2", :"tlsv1.3"] ] ] options = [body_format: :binary] case :httpc.request( :get, {~c"https://hex.pm/api/packages/#{name}", [{~c"user-agent", ~c"Mix.Tasks.Phx.New/#{@version}"}]}, http_options, options ) do {:ok, {{_, 200, _}, _headers, body}} -> {:ok, JSON.decode!(body)} {:ok, {{_, status, _}, _, _}} -> {:error, status} {:error, reason} -> {:error, reason} end end else defp get_latest_version(_), do: nil end end ================================================ FILE: installer/lib/mix/tasks/phx.new.web.ex ================================================ defmodule Mix.Tasks.Phx.New.Web do @moduledoc """ Creates a new Phoenix web project within an umbrella project. It expects the name of the OTP app as the first argument and for the command to be run inside your umbrella application's apps directory: $ cd my_umbrella/apps $ mix phx.new.web APP [--module MODULE] [--app APP] This task is intended to create a bare Phoenix project without database integration, which interfaces with your greater umbrella application(s). ## Examples $ mix phx.new.web hello_web Is equivalent to: $ mix phx.new.web hello_web --module HelloWeb Supports the same options as the `phx.new` task. See `Mix.Tasks.Phx.New` for details. """ @shortdoc "Creates a new Phoenix web project within an umbrella project" use Mix.Task @impl true def run([]) do Mix.Tasks.Help.run(["phx.new.web"]) end def run([path | _] = args) do unless Phx.New.Generator.in_umbrella?(path) do Mix.raise "The web task can only be run within an umbrella's apps directory" end Mix.Tasks.Phx.New.run(args, Phx.New.Web, :web_path) end end ================================================ FILE: installer/lib/phx_new/ecto.ex ================================================ defmodule Phx.New.Ecto do @moduledoc false use Phx.New.Generator alias Phx.New.{Project} @pre "phx_umbrella/apps/app_name" template(:new, [ {:config, :project, "#{@pre}/config/config.exs.eex": "config/config.exs"}, {:eex, :app, "#{@pre}/lib/app_name/application.ex.eex": "lib/:app/application.ex", "#{@pre}/lib/app_name.ex.eex": "lib/:app.ex", "#{@pre}/test/test_helper.exs.eex": "test/test_helper.exs", "#{@pre}/README.md.eex": "README.md", "#{@pre}/mix.exs.eex": "mix.exs", "#{@pre}/gitignore.eex": ".gitignore", "#{@pre}/formatter.exs.eex": ".formatter.exs"} ]) def prepare_project(%Project{} = project) do app_path = Path.expand(project.base_path) project_path = Path.dirname(Path.dirname(app_path)) %{project | in_umbrella?: true, app_path: app_path, project_path: project_path} end def generate(%Project{} = project) do inject_umbrella_config_defaults(project) copy_from(project, __MODULE__, :new) if Project.ecto?(project), do: Phx.New.Single.gen_ecto(project) project end end ================================================ FILE: installer/lib/phx_new/generator.ex ================================================ defmodule Phx.New.Generator do @moduledoc false import Mix.Generator alias Phx.New.{Project} @phoenix Path.expand("../..", __DIR__) @phoenix_version Version.parse!(Mix.Project.config()[:version]) @callback prepare_project(Project.t()) :: Project.t() @callback generate(Project.t()) :: Project.t() defmacro __using__(_env) do quote do @behaviour unquote(__MODULE__) import Mix.Generator import unquote(__MODULE__) Module.register_attribute(__MODULE__, :templates, accumulate: true) @before_compile unquote(__MODULE__) end end defmacro __before_compile__(env) do root = Path.expand("../../templates", __DIR__) templates_ast = for {name, mappings} <- Module.get_attribute(env.module, :templates) do for {format, _proj_location, files} <- mappings, format != :keep, {source, _target} <- files, source = to_string(source) do path = Path.join(root, source) if format in [:config, :prod_config, :eex] do compiled = EEx.compile_file(path) quote do @external_resource unquote(path) @file unquote(path) def render(unquote(name), unquote(source), var!(assigns)) when is_list(var!(assigns)) do var!(maybe_heex_attr_gettext) = &unquote(__MODULE__).maybe_heex_attr_gettext/2 _ = var!(maybe_heex_attr_gettext) var!(maybe_eex_gettext) = &unquote(__MODULE__).maybe_eex_gettext/2 _ = var!(maybe_eex_gettext) unquote(compiled) end end else quote do @external_resource unquote(path) def render(unquote(name), unquote(source), _assigns), do: unquote(File.read!(path)) end end end end quote do unquote(templates_ast) def template_files(name), do: Keyword.fetch!(@templates, name) end end defmacro template(name, mappings) do quote do @templates {unquote(name), unquote(mappings)} end end def copy_from(%Project{} = project, mod, name) when is_atom(name) do mapping = mod.template_files(name) for {format, project_location, files} <- mapping, {source, target_path} <- files, source = to_string(source) do target = Project.join_path(project, project_location, target_path) case format do :keep -> File.mkdir_p!(target) :text -> create_file(target, mod.render(name, source, project.binding)) :config -> contents = mod.render(name, source, project.binding) config_inject(Path.dirname(target), Path.basename(target), contents) :prod_config -> contents = mod.render(name, source, project.binding) prod_only_config_inject(Path.dirname(target), Path.basename(target), contents) :eex -> contents = mod.render(name, source, project.binding) create_file(target, contents) end end end parent_rules = Path.join(@phoenix, "../usage-rules") # those are copied before publishing to Hex copied_rules = Path.expand("../../templates/phoenix-usage-rules", __DIR__) @usage_rules_path if(File.exists?(parent_rules), do: parent_rules, else: copied_rules) @rules_files Map.new(File.ls!(@usage_rules_path), fn file -> content = File.read!(Path.join(@usage_rules_path, file)) {file, String.trim_trailing(content)} end) @new_project_rules_files Map.new( File.ls!(Path.expand("../../templates/usage-rules", __DIR__)), fn file -> base_path = Path.expand("../../templates/usage-rules", __DIR__) content = File.read!(Path.join(base_path, file)) {file, String.trim_trailing(content)} end ) def generate_agents_md(%Project{} = project) do if project.binding[:agents_md] do content = [ # rules specific to new apps @new_project_rules_files["project.md"], @new_project_rules_files["phoenix.md"], # --no-assets is equivalent to --no-tailwind && --no-esbuild; # we check for both here project.binding[:javascript] && project.binding[:css] && @new_project_rules_files["assets.md"], # generic usage rules "\n", [ "\n", @rules_files["elixir.md"], "\n" ], [ "\n", @rules_files["phoenix.md"], "\n" ], project.binding[:ecto] && [ "\n", @rules_files["ecto.md"], "\n" ], project.binding[:html] && [ "\n", @rules_files["html.md"], "\n" ], project.binding[:live] && [ "\n", @rules_files["liveview.md"], "\n" ], "" ] |> Enum.reject(fn part -> part == nil or part == false end) |> Enum.intersperse("\n\n") File.write!(Path.join(project.project_path, "AGENTS.md"), content) end end def config_inject(path, file, to_inject) do file = Path.join(path, file) contents = case File.read(file) do {:ok, bin} -> bin {:error, _} -> "import Config\n" end case :binary.split(contents, "import Config") do [left, right] -> write_formatted!(file, [left, to_inject, right]) [_] -> Mix.raise(~s[Could not find "import Config" in #{inspect(file)}]) end end def prod_only_config_inject(path, file, to_inject) do file = Path.join(path, file) contents = case File.read(file) do {:ok, bin} -> bin {:error, _} -> """ import Config if config_env() == :prod do end """ end case :binary.split(contents, "if config_env() == :prod do") do [left, right] -> write_formatted!(file, [left, "if config_env() == :prod do\n", to_inject, right]) [_] -> Mix.raise(~s[Could not find "if config_env() == :prod do" in #{inspect(file)}]) end end defp write_formatted!(file, contents) do formatted = contents |> IO.iodata_to_binary() |> Code.format_string!() File.mkdir_p!(Path.dirname(file)) File.write!(file, [formatted, ?\n]) end def inject_umbrella_config_defaults(project) do unless File.exists?(Project.join_path(project, :project, "config/dev.exs")) do path = Project.join_path(project, :project, "config/config.exs") extra = Phx.New.Umbrella.render(:new, "phx_umbrella/config/extra_config.exs.eex", project.binding) File.write(path, [File.read!(path), extra]) end end def in_umbrella?(app_path) do umbrella = Path.expand(Path.join([app_path, "..", ".."])) mix_path = Path.join(umbrella, "mix.exs") apps_path = Path.join(umbrella, "apps") File.exists?(mix_path) && File.exists?(apps_path) end def put_binding(%Project{opts: opts} = project) do db = Keyword.get(opts, :database, "postgres") web_adapter = Keyword.get(opts, :adapter, "bandit") ecto = Keyword.get(opts, :ecto, true) html = Keyword.get(opts, :html, true) live = html && Keyword.get(opts, :live, true) dashboard = Keyword.get(opts, :dashboard, true) gettext = Keyword.get(opts, :gettext, true) assets = Keyword.get(opts, :assets, true) esbuild = Keyword.get(opts, :esbuild, assets) tailwind = Keyword.get(opts, :tailwind, assets) mailer = Keyword.get(opts, :mailer, true) dev = Keyword.get(opts, :dev, false) from_elixir_install = Keyword.get(opts, :from_elixir_install, false) phoenix_path = phoenix_path(project, dev, false) phoenix_path_umbrella_root = phoenix_path(project, dev, true) agents_md = Keyword.get(opts, :agents_md, true) # detect if we're inside a docker env, but if we're in github actions, # we want to treat it like regular env for end-user testing purposes inside_docker_env? = Keyword.get_lazy(opts, :inside_docker_env, fn -> if System.get_env("PHX_CI") do false else File.exists?("/.dockerenv") end end) # We lowercase the database name because according to the # SQL spec, they are case insensitive unless quoted, which # means creating a database like FoO is the same as foo in # some storages. {adapter_app, adapter_module, adapter_config} = get_ecto_adapter(db, String.downcase(project.app), project.app_mod) {web_adapter_app, web_adapter_vsn, web_adapter_module, web_adapter_docs} = get_web_adapter(web_adapter) pubsub_server = get_pubsub_server(project.app_mod) adapter_config = case Keyword.fetch(opts, :binary_id) do {:ok, value} -> Keyword.put_new(adapter_config, :binary_id, value) :error -> adapter_config end binding = [ app_name: project.app, app_module: inspect(project.app_mod), root_app_name: project.root_app, root_app_module: inspect(project.root_mod), lib_web_name: project.lib_web_name, web_app_name: project.web_app, endpoint_module: inspect(Module.concat(project.web_namespace, Endpoint)), web_namespace: inspect(project.web_namespace), phoenix_dep: phoenix_dep(phoenix_path), phoenix_dep_umbrella_root: phoenix_dep(phoenix_path_umbrella_root), phoenix_js_path: phoenix_js_path(phoenix_path), phoenix_version: @phoenix_version, pubsub_server: pubsub_server, secret_key_base_dev: random_string(64), secret_key_base_test: random_string(64), signing_salt: random_string(8), lv_signing_salt: random_string(8), in_umbrella: project.in_umbrella?, asset_builders: Enum.filter([tailwind && :tailwind, esbuild && :esbuild], & &1), javascript: esbuild, css: tailwind, mailer: mailer, ecto: ecto, html: html, live: live, live_comment: if(live, do: nil, else: "// "), dashboard: dashboard, gettext: gettext, adapter_app: adapter_app, adapter_module: adapter_module, adapter_config: adapter_config, web_adapter_app: web_adapter_app, web_adapter_module: web_adapter_module, web_adapter_vsn: web_adapter_vsn, web_adapter_docs: web_adapter_docs, generators: nil_if_empty(project.generators ++ adapter_generators(adapter_config)), namespaced?: namespaced?(project), dev: dev, from_elixir_install: from_elixir_install, elixir_install_otp_bin_path: from_elixir_install && elixir_install_otp_bin_path(), elixir_install_bin_path: from_elixir_install && elixir_install_bin_path(), inside_docker_env?: inside_docker_env?, agents_md: agents_md, config_regex_E: Version.match?(System.version(), "~> 1.19.3 or ~> 1.20") && "E" || "" ] %{project | binding: binding} end def elixir_install_otp_bin_path do "erl" |> System.find_executable() |> Path.split() |> Enum.drop(-1) |> Path.join() |> Path.relative_to(System.user_home()) end def elixir_install_bin_path do "elixir" |> System.find_executable() |> Path.split() |> Enum.drop(-1) |> Path.join() |> Path.relative_to(System.user_home()) end defp namespaced?(project) do Macro.camelize(project.app) != inspect(project.app_mod) end def gen_ecto_config(%Project{project_path: project_path, binding: binding}) do adapter_config = binding[:adapter_config] config_inject(project_path, "config/dev.exs", """ import Config # Configure your database config :#{binding[:app_name]}, #{binding[:app_module]}.Repo#{kw_to_config(adapter_config[:dev])} """) config_inject(project_path, "config/test.exs", """ 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 :#{binding[:app_name]}, #{binding[:app_module]}.Repo#{kw_to_config(adapter_config[:test])} """) prod_only_config_inject(project_path, "config/runtime.exs", """ #{adapter_config[:prod_variables]} config :#{binding[:app_name]}, #{binding[:app_module]}.Repo, #{adapter_config[:prod_config]} """) end defp get_pubsub_server(module) do module |> Module.split() |> hd() |> Module.concat(PubSub) end defp get_ecto_adapter("mssql", app, module) do {:tds, Ecto.Adapters.Tds, socket_db_config(app, module, "sa", "some!Password")} end defp get_ecto_adapter("mysql", app, module) do {:myxql, Ecto.Adapters.MyXQL, socket_db_config(app, module, "root", "")} end defp get_ecto_adapter("postgres", app, module) do {:postgrex, Ecto.Adapters.Postgres, socket_db_config(app, module, "postgres", "postgres")} end defp get_ecto_adapter("sqlite3", app, module) do {:ecto_sqlite3, Ecto.Adapters.SQLite3, fs_db_config(app, module)} end defp get_ecto_adapter(db, _app, _mod) do Mix.raise("Unknown database #{inspect(db)}") end defp get_web_adapter("cowboy"), do: {:plug_cowboy, "~> 2.7", Phoenix.Endpoint.Cowboy2Adapter, "https://hexdocs.pm/plug_cowboy/Plug.Cowboy.html"} defp get_web_adapter("bandit"), do: {:bandit, "~> 1.5", Bandit.PhoenixAdapter, "https://hexdocs.pm/bandit/Bandit.html#t:options/0"} defp get_web_adapter(other), do: Mix.raise("Unknown web adapter #{inspect(other)}") defp fs_db_config(app, module) do [ dev: [ database: {:literal, ~s|Path.expand("../#{app}_dev.db", __DIR__)|}, pool_size: 5, stacktrace: true, show_sensitive_data_on_connection_error: true ], test: [ database: {:literal, ~s|Path.expand("../#{app}_test.db", __DIR__)|}, pool_size: 5, pool: Ecto.Adapters.SQL.Sandbox ], test_setup_all: "Ecto.Adapters.SQL.Sandbox.mode(#{inspect(module)}.Repo, :manual)", test_setup: """ pid = Ecto.Adapters.SQL.Sandbox.start_owner!(#{inspect(module)}.Repo, shared: not tags[:async]) on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end)\ """, prod_variables: """ database_path = System.get_env("DATABASE_PATH") || raise \""" environment variable DATABASE_PATH is missing. For example: /etc/#{app}/#{app}.db \""" """, prod_config: """ database: database_path, pool_size: String.to_integer(System.get_env("POOL_SIZE") || "5") """ ] end defp socket_db_config(app, module, user, pass) do [ dev: [ username: user, password: pass, hostname: "localhost", database: "#{app}_dev", stacktrace: true, show_sensitive_data_on_connection_error: true, pool_size: 10 ], test: [ username: user, password: pass, hostname: "localhost", database: {:literal, ~s|"#{app}_test\#{System.get_env("MIX_TEST_PARTITION")}"|}, pool: Ecto.Adapters.SQL.Sandbox, pool_size: {:literal, ~s|System.schedulers_online() * 2|} ], test_setup_all: "Ecto.Adapters.SQL.Sandbox.mode(#{inspect(module)}.Repo, :manual)", test_setup: """ pid = Ecto.Adapters.SQL.Sandbox.start_owner!(#{inspect(module)}.Repo, shared: not tags[:async]) on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end)\ """, prod_variables: """ 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: [] """, prod_config: """ # 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 """ ] end defp kw_to_config(kw) do Enum.map(kw, fn {k, {:literal, v}} -> ",\n #{k}: #{v}" {k, v} -> ",\n #{k}: #{inspect(v)}" end) end defp adapter_generators(adapter_config) do adapter_config |> Keyword.take([:binary_id, :migration, :sample_binary_id]) |> Enum.filter(fn {_, value} -> not is_nil(value) end) end defp nil_if_empty([]), do: nil defp nil_if_empty(other), do: other defp phoenix_path(%Project{} = project, true = _dev, umbrella_root?) do absolute = Path.expand(project.project_path) relative = Path.relative_to(absolute, @phoenix) if absolute == relative do Mix.raise("--dev projects must be generated inside Phoenix directory") end project |> phoenix_path_prefix(umbrella_root?) |> Path.join(relative) |> Path.split() |> Enum.map(fn _ -> ".." end) |> Path.join() end defp phoenix_path(%Project{}, false = _dev, _umbrella_root?) do "deps/phoenix" end defp phoenix_path_prefix(%Project{in_umbrella?: false}, _), do: ".." defp phoenix_path_prefix(%Project{in_umbrella?: true}, true = _umbrella_root?), do: ".." defp phoenix_path_prefix(%Project{in_umbrella?: true}, false = _umbrella_root?), do: "../../../" case @phoenix_version do %Version{pre: "dev"} -> defp phoenix_dep("deps/phoenix") do ~s[{:phoenix, github: "phoenixframework/phoenix", override: true}] end %Version{pre: ["rc", _]} -> defp phoenix_dep("deps/phoenix") do ~s[{:phoenix, "~> #{unquote(to_string(@phoenix_version))}", override: true}] end %Version{} -> defp phoenix_dep("deps/phoenix") do ~s[{:phoenix, "~> #{unquote(to_string(@phoenix_version))}"}] end end defp phoenix_dep(path), do: ~s[{:phoenix, path: #{inspect(path)}, override: true}] defp phoenix_js_path("deps/phoenix"), do: "phoenix" defp phoenix_js_path(path), do: "../../#{path}/" defp random_string(length) do :crypto.strong_rand_bytes(length) |> Base.encode64(padding: false) |> binary_part(0, length) end # In the context of a HEEx attribute value, transforms a given message into a # dynamic `gettext` call or a fixed-value string attribute, depending on the # `gettext?` parameter. # # ## Examples # # iex> ~s|| # ~S|| # # iex> ~s|| # ~S|| def maybe_heex_attr_gettext(message, gettext?) do if gettext? do ~s|{gettext(#{inspect(message)})}| else inspect(message) end end # In the context of an EEx template, transforms a given message into a dynamic # `gettext` call or the message as is, depending on the `gettext?` parameter. # # ## Examples # # iex> ~s|#{maybe_eex_gettext("Hello", true)}| # ~S|{gettext("Hello")}| # # iex> ~s|#{maybe_eex_gettext("Hello", false)}| # ~S|Hello| def maybe_eex_gettext(message, gettext?) do if gettext? do ~s|{gettext(#{inspect(message)})}| else message end end end ================================================ FILE: installer/lib/phx_new/mailer.ex ================================================ defmodule Phx.New.Mailer do @moduledoc false use Phx.New.Generator alias Phx.New.{Project} template(:new, [ {:eex, :app, "phx_mailer/lib/app_name/mailer.ex.eex": "lib/:app/mailer.ex"} ]) def prepare_project(%Project{} = project) do app_path = Path.expand(project.base_path) project_path = Path.dirname(Path.dirname(app_path)) %{project | in_umbrella?: true, app_path: app_path, project_path: project_path} end def generate(%Project{} = project) do inject_umbrella_config_defaults(project) copy_from(project, __MODULE__, :new) project end end ================================================ FILE: installer/lib/phx_new/project.ex ================================================ defmodule Phx.New.Project do @moduledoc false alias Phx.New.Project defstruct base_path: nil, app: nil, app_mod: nil, app_path: nil, lib_web_name: nil, root_app: nil, root_mod: nil, project_path: nil, web_app: nil, web_namespace: nil, web_path: nil, opts: :unset, in_umbrella?: false, binding: [], cached_build_path: nil, generators: [timestamp_type: :utc_datetime] def new(project_path, opts) do project_path = Path.expand(project_path) app = opts[:app] || Path.basename(project_path) app_mod = Module.concat([opts[:module] || Macro.camelize(app)]) %Project{ base_path: project_path, app: app, app_mod: app_mod, root_app: app, root_mod: app_mod, opts: opts } end def ecto?(%Project{binding: binding}) do Keyword.fetch!(binding, :ecto) end def html?(%Project{binding: binding}) do Keyword.fetch!(binding, :html) end def gettext?(%Project{binding: binding}) do Keyword.fetch!(binding, :gettext) end def live?(%Project{binding: binding}) do Keyword.fetch!(binding, :live) end def dashboard?(%Project{binding: binding}) do Keyword.fetch!(binding, :dashboard) end def javascript?(%Project{binding: binding}) do Keyword.fetch!(binding, :javascript) end def css?(%Project{binding: binding}) do Keyword.fetch!(binding, :css) end def mailer?(%Project{binding: binding}) do Keyword.fetch!(binding, :mailer) end def verbose?(%Project{opts: opts}) do Keyword.get(opts, :verbose, false) end def join_path(%Project{} = project, location, path) when location in [:project, :app, :web] do project |> Map.fetch!(:"#{location}_path") |> Path.join(path) |> expand_path_with_bindings(project) end defp expand_path_with_bindings(path, %Project{} = project) do Regex.replace(Regex.recompile!(~r/:[a-zA-Z0-9_]+/), path, fn ":" <> key, _ -> project |> Map.fetch!(:"#{key}") |> to_string() end) end end ================================================ FILE: installer/lib/phx_new/single.ex ================================================ defmodule Phx.New.Single do @moduledoc false use Phx.New.Generator alias Phx.New.{Project} template(:new, [ {:config, :project, "phx_single/config/config.exs.eex": "config/config.exs", "phx_single/config/dev.exs.eex": "config/dev.exs", "phx_single/config/prod.exs.eex": "config/prod.exs", "phx_single/config/runtime.exs.eex": "config/runtime.exs", "phx_single/config/test.exs.eex": "config/test.exs"}, {:eex, :web, "phx_single/lib/app_name/application.ex.eex": "lib/:app/application.ex", "phx_single/lib/app_name.ex.eex": "lib/:app.ex", "phx_web/controllers/error_json.ex.eex": "lib/:lib_web_name/controllers/error_json.ex", "phx_web/endpoint.ex.eex": "lib/:lib_web_name/endpoint.ex", "phx_web/router.ex.eex": "lib/:lib_web_name/router.ex", "phx_web/telemetry.ex.eex": "lib/:lib_web_name/telemetry.ex", "phx_single/lib/app_name_web.ex.eex": "lib/:lib_web_name.ex", "phx_single/mix.exs.eex": "mix.exs", "phx_single/README.md.eex": "README.md", "phx_single/formatter.exs.eex": ".formatter.exs", "phx_single/gitignore.eex": ".gitignore", "phx_test/support/conn_case.ex.eex": "test/support/conn_case.ex", "phx_single/test/test_helper.exs.eex": "test/test_helper.exs", "phx_test/controllers/error_json_test.exs.eex": "test/:lib_web_name/controllers/error_json_test.exs"}, {:keep, :web, "phx_web/controllers": "lib/:lib_web_name/controllers", "phx_test/controllers": "test/:lib_web_name/controllers"} ]) template(:gettext, [ {:eex, :web, "phx_gettext/gettext.ex.eex": "lib/:lib_web_name/gettext.ex", "phx_gettext/en/LC_MESSAGES/errors.po.eex": "priv/gettext/en/LC_MESSAGES/errors.po", "phx_gettext/errors.pot.eex": "priv/gettext/errors.pot"} ]) template(:html, [ {:eex, :web, "phx_web/controllers/error_html.ex.eex": "lib/:lib_web_name/controllers/error_html.ex", "phx_test/controllers/error_html_test.exs.eex": "test/:lib_web_name/controllers/error_html_test.exs", "phx_web/components/core_components.ex.eex": "lib/:lib_web_name/components/core_components.ex", "phx_web/controllers/page_controller.ex.eex": "lib/:lib_web_name/controllers/page_controller.ex", "phx_web/controllers/page_html.ex.eex": "lib/:lib_web_name/controllers/page_html.ex", "phx_web/controllers/page_html/home.html.heex.eex": "lib/:lib_web_name/controllers/page_html/home.html.heex", "phx_test/controllers/page_controller_test.exs.eex": "test/:lib_web_name/controllers/page_controller_test.exs", "phx_web/components/layouts/root.html.heex.eex": "lib/:lib_web_name/components/layouts/root.html.heex", "phx_web/components/layouts.ex.eex": "lib/:lib_web_name/components/layouts.ex"}, {:eex, :web, "phx_assets/logo.svg.eex": "priv/static/images/logo.svg"} ]) template(:ecto, [ {:eex, :app, "phx_ecto/repo.ex.eex": "lib/:app/repo.ex", "phx_ecto/formatter.exs.eex": "priv/repo/migrations/.formatter.exs", "phx_ecto/seeds.exs.eex": "priv/repo/seeds.exs", "phx_ecto/data_case.ex.eex": "test/support/data_case.ex"}, {:keep, :app, "phx_ecto/priv/repo/migrations": "priv/repo/migrations"} ]) template(:css, [ {:eex, :web, "phx_assets/app.css.eex": "assets/css/app.css", "phx_assets/heroicons.js.eex": "assets/vendor/heroicons.js", "phx_assets/daisyui.js.eex": "assets/vendor/daisyui.js", "phx_assets/daisyui-theme.js.eex": "assets/vendor/daisyui-theme.js"} ]) template(:js, [ {:eex, :web, "phx_assets/app.js.eex": "assets/js/app.js", "phx_assets/topbar.js.eex": "assets/vendor/topbar.js", "phx_assets/tsconfig.json.eex": "assets/tsconfig.json"} ]) template(:no_js, [ {:text, :web, "phx_static/app.js": "priv/static/assets/js/app.js"} ]) template(:no_css, [ { :text, :web, # the default.css file can be re-created by using the recreate_default_css.exs file # in the installer folder: `elixir installer/recreate_default_css.exs` "phx_static/app.css": "priv/static/assets/css/app.css", "phx_static/default.css": "priv/static/assets/default.css" } ]) template(:static, [ {:text, :web, "phx_static/robots.txt": "priv/static/robots.txt", "phx_static/favicon.ico": "priv/static/favicon.ico"} ]) template(:mailer, [ {:eex, :app, "phx_mailer/lib/app_name/mailer.ex.eex": "lib/:app/mailer.ex"} ]) def prepare_project(%Project{app: app, base_path: base_path} = project) when not is_nil(app) do if in_umbrella?(base_path) do %{project | in_umbrella?: true, project_path: Path.dirname(Path.dirname(base_path))} else %{project | in_umbrella?: false, project_path: base_path} end |> put_app() |> put_root_app() |> put_web_app() end defp put_app(%Project{base_path: base_path} = project) do %{project | app_path: base_path} end defp put_root_app(%Project{app: app, opts: opts} = project) do %{ project | root_app: app, root_mod: Module.concat([opts[:module] || Macro.camelize(app)]) } end defp put_web_app(%Project{app: app} = project) do %{ project | web_app: app, lib_web_name: "#{app}_web", web_namespace: Module.concat(["#{project.root_mod}Web"]), web_path: project.base_path } end def generate(%Project{} = project) do copy_from(project, __MODULE__, :new) generate_agents_md(project) if Project.ecto?(project), do: gen_ecto(project) if Project.html?(project), do: gen_html(project) if Project.mailer?(project), do: gen_mailer(project) if Project.gettext?(project), do: gen_gettext(project) gen_assets(project) project end def gen_html(project) do copy_from(project, __MODULE__, :html) end def gen_gettext(project) do copy_from(project, __MODULE__, :gettext) end def gen_ecto(project) do copy_from(project, __MODULE__, :ecto) gen_ecto_config(project) end def gen_assets(%Project{} = project) do javascript? = Project.javascript?(project) css? = Project.css?(project) html? = Project.html?(project) copy_from(project, __MODULE__, :static) if html? or javascript? do command = if javascript?, do: :js, else: :no_js copy_from(project, __MODULE__, command) end if html? or css? do command = if css?, do: :css, else: :no_css copy_from(project, __MODULE__, command) end end def gen_mailer(%Project{} = project) do copy_from(project, __MODULE__, :mailer) end end ================================================ FILE: installer/lib/phx_new/umbrella.ex ================================================ defmodule Phx.New.Umbrella do @moduledoc false use Phx.New.Generator alias Phx.New.{Ecto, Web, Project, Mailer} template(:new, [ {:eex, :project, "phx_umbrella/gitignore.eex": ".gitignore", "phx_umbrella/config/config.exs.eex": "config/config.exs", "phx_umbrella/config/dev.exs.eex": "config/dev.exs", "phx_umbrella/config/test.exs.eex": "config/test.exs", "phx_umbrella/config/prod.exs.eex": "config/prod.exs", "phx_umbrella/config/runtime.exs.eex": "config/runtime.exs", "phx_umbrella/mix.exs.eex": "mix.exs", "phx_umbrella/README.md.eex": "README.md", "phx_umbrella/formatter.exs.eex": ".formatter.exs"}, {:config, :project, "phx_umbrella/config/extra_config.exs.eex": "config/config.exs"} ]) def prepare_project(%Project{app: app} = project) when not is_nil(app) do project |> put_app() |> put_web() |> put_root_app() end defp put_app(project) do project_path = Path.expand(project.base_path <> "_umbrella") app_path = Path.join(project_path, "apps/#{project.app}") %{project | in_umbrella?: true, app_path: app_path, project_path: project_path} end def put_web(%Project{app: app, opts: opts} = project) do web_app = :"#{app}_web" web_namespace = Module.concat([opts[:web_module] || "#{project.app_mod}Web"]) %{ project | web_app: web_app, lib_web_name: web_app, web_namespace: web_namespace, generators: [context_app: :"#{app}"], web_path: Path.join(project.project_path, "apps/#{web_app}/") } end defp put_root_app(%Project{app: app} = project) do %{ project | root_app: :"#{app}_umbrella", root_mod: Module.concat(project.app_mod, "Umbrella") } end def generate(%Project{} = project) do if in_umbrella?(project.project_path) do Mix.raise("Unable to nest umbrella project within apps") end copy_from(project, __MODULE__, :new) generate_agents_md(project) project |> Web.generate() |> Ecto.generate() |> maybe_generate_mailer() end defp maybe_generate_mailer(project) do if Project.mailer?(project) do Mailer.generate(project) else project end end end ================================================ FILE: installer/lib/phx_new/web.ex ================================================ defmodule Phx.New.Web do @moduledoc false use Phx.New.Generator alias Phx.New.{Project} @pre "phx_umbrella/apps/app_name_web" template(:new, [ {:prod_config, :project, "#{@pre}/config/runtime.exs.eex": "config/runtime.exs"}, {:config, :project, "#{@pre}/config/config.exs.eex": "config/config.exs", "#{@pre}/config/dev.exs.eex": "config/dev.exs", "#{@pre}/config/prod.exs.eex": "config/prod.exs", "#{@pre}/config/test.exs.eex": "config/test.exs"}, {:keep, :web, "phx_web/controllers": "lib/:web_app/controllers", "phx_test/channels": "test/:web_app/channels", "phx_test/controllers": "test/:web_app/controllers"}, {:eex, :web, "#{@pre}/lib/app_name.ex.eex": "lib/:web_app.ex", "#{@pre}/lib/app_name/application.ex.eex": "lib/:web_app/application.ex", "phx_web/endpoint.ex.eex": "lib/:web_app/endpoint.ex", "phx_web/router.ex.eex": "lib/:web_app/router.ex", "phx_web/telemetry.ex.eex": "lib/:web_app/telemetry.ex", "phx_web/controllers/error_json.ex.eex": "lib/:web_app/controllers/error_json.ex", "#{@pre}/mix.exs.eex": "mix.exs", "#{@pre}/README.md.eex": "README.md", "#{@pre}/gitignore.eex": ".gitignore", "#{@pre}/test/test_helper.exs.eex": "test/test_helper.exs", "phx_test/support/conn_case.ex.eex": "test/support/conn_case.ex", "phx_test/controllers/error_json_test.exs.eex": "test/:web_app/controllers/error_json_test.exs", "#{@pre}/formatter.exs.eex": ".formatter.exs"} ]) template(:gettext, [ {:eex, :web, "phx_gettext/gettext.ex.eex": "lib/:web_app/gettext.ex", "phx_gettext/en/LC_MESSAGES/errors.po.eex": "priv/gettext/en/LC_MESSAGES/errors.po", "phx_gettext/errors.pot.eex": "priv/gettext/errors.pot"} ]) template(:html, [ {:eex, :web, "phx_web/components/core_components.ex.eex": "lib/:web_app/components/core_components.ex", "phx_web/components/layouts.ex.eex": "lib/:web_app/components/layouts.ex", "phx_web/controllers/page_controller.ex.eex": "lib/:web_app/controllers/page_controller.ex", "phx_web/controllers/error_html.ex.eex": "lib/:web_app/controllers/error_html.ex", "phx_web/controllers/page_html.ex.eex": "lib/:web_app/controllers/page_html.ex", "phx_web/controllers/page_html/home.html.heex.eex": "lib/:web_app/controllers/page_html/home.html.heex", "phx_test/controllers/page_controller_test.exs.eex": "test/:web_app/controllers/page_controller_test.exs", "phx_test/controllers/error_html_test.exs.eex": "test/:web_app/controllers/error_html_test.exs", "phx_assets/topbar.js.eex": "assets/vendor/topbar.js", "phx_web/components/layouts/root.html.heex.eex": "lib/:web_app/components/layouts/root.html.heex"}, {:eex, :web, "phx_assets/logo.svg.eex": "priv/static/images/logo.svg"} ]) def prepare_project(%Project{app: app} = project) when not is_nil(app) do web_path = Path.expand(project.base_path) project_path = Path.dirname(Path.dirname(web_path)) %{ project | in_umbrella?: true, project_path: project_path, web_path: web_path, web_app: app, generators: [context_app: false], web_namespace: project.app_mod } end def generate(%Project{} = project) do inject_umbrella_config_defaults(project) copy_from(project, __MODULE__, :new) if Project.html?(project), do: gen_html(project) if Project.gettext?(project), do: gen_gettext(project) Phx.New.Single.gen_assets(project) project end defp gen_html(%Project{} = project) do copy_from(project, __MODULE__, :html) end defp gen_gettext(%Project{} = project) do copy_from(project, __MODULE__, :gettext) end end ================================================ FILE: installer/mix.exs ================================================ for path <- :code.get_path(), Regex.match?(~r/phx_new-[\w\.\-]+\/ebin$/, List.to_string(path)) do Code.delete_path(path) end defmodule Phx.New.MixProject do use Mix.Project @version "1.8.5" @scm_url "https://github.com/phoenixframework/phoenix" # If the elixir requirement is updated, we need to update: # # 1. all mix.exs generated by the installer # 2. guides/introduction/installation.md # 3. guides/deployment/releases.md # 4. test/test_helper.exs at the root # 5. installer/lib/mix/tasks/phx.new.ex # @elixir_requirement "~> 1.15" def project do [ app: :phx_new, start_permanent: Mix.env() == :prod, version: @version, elixir: @elixir_requirement, deps: deps(), aliases: aliases(), package: [ maintainers: [ "Chris McCord", "José Valim", "Gary Rennie", "Jason Stiebs" ], licenses: ["MIT"], links: %{"GitHub" => @scm_url}, files: ~w(lib templates mix.exs README.md) ], source_url: @scm_url, docs: docs(), homepage_url: "https://www.phoenixframework.org", description: """ Phoenix framework project generator. Provides a `mix phx.new` task to bootstrap a new Elixir application with Phoenix dependencies. """ ] end def cli do [preferred_envs: [docs: :docs]] end def application do [ extra_applications: [:eex, :crypto, :public_key] ] end def deps do [ {:ex_doc, "~> 0.24", only: :docs} ] end defp docs do [ source_url_pattern: "#{@scm_url}/blob/v#{@version}/installer/%{path}#L%{line}" ] end defp aliases do [ "hex.publish": [ ©_agents_md/1, "hex.publish" ] ] end defp copy_agents_md(_) do File.cp_r!( Path.expand("../usage-rules", __DIR__), Path.expand("./templates/phoenix-usage-rules", __DIR__) ) end end ================================================ FILE: installer/recreate_default_css.exs ================================================ File.rm_rf!("installer/dayzee") shell! = fn command, opts -> {_, 0} = System.shell( command, Keyword.merge( [ into: IO.binstream(:stdio, :line), stderr_to_stdout: true ], opts ) ) end shell_in_daisy! = fn command -> shell!.(command, cd: Path.expand("dayzee")) end File.cd!("installer", fn -> shell!.("mix phx.new dayzee --dev --database sqlite3 --install", []) shell_in_daisy!.("mix phx.gen.auth Accounts User users --live") shell_in_daisy!.("mix deps.get") shell_in_daisy!.("mix phx.gen.live Blog Post posts title:string body:text") shell_in_daisy!.("mix tailwind dayzee") content = File.read!("dayzee/priv/static/assets/css/app.css") File.write!("templates/phx_static/default.css", """ /* These are daisyUI styles for styling the default CoreComponents and generator files * included to prevent shipping a completely unstyled page, even as you selected --no-tailwind. * You can safely remove the whole file and all references to "default.css". */ #{content} """) end) File.rm_rf!("installer/dayzee") ================================================ FILE: installer/templates/phx_assets/app.css.eex ================================================ /* See the Tailwind configuration guide for advanced usage https://tailwindcss.com/docs/configuration */ @import "tailwindcss" source(none); @source "../css"; @source "../js"; @source "../../lib/<%= @lib_web_name || @app_name %>"; /* A Tailwind plugin that makes "hero-#{ICON}" classes available. The heroicons installation itself is managed by your mix.exs */ @plugin "../vendor/heroicons"; /* daisyUI Tailwind Plugin. You can update this file by fetching the latest version with: curl -sLO https://github.com/saadeghi/daisyui/releases/latest/download/daisyui.js Make sure to look at the daisyUI changelog: https://daisyui.com/docs/changelog/ */ @plugin "../vendor/daisyui" { themes: false; } /* daisyUI theme plugin. You can update this file by fetching the latest version with: curl -sLO https://github.com/saadeghi/daisyui/releases/latest/download/daisyui-theme.js We ship with two themes, a light one inspired on Phoenix colors and a dark one inspired on Elixir colors. Build your own at: https://daisyui.com/theme-generator/ */ @plugin "../vendor/daisyui-theme" { name: "dark"; default: false; prefersdark: true; color-scheme: "dark"; --color-base-100: oklch(30.33% 0.016 252.42); --color-base-200: oklch(25.26% 0.014 253.1); --color-base-300: oklch(20.15% 0.012 254.09); --color-base-content: oklch(97.807% 0.029 256.847); --color-primary: oklch(58% 0.233 277.117); --color-primary-content: oklch(96% 0.018 272.314); --color-secondary: oklch(58% 0.233 277.117); --color-secondary-content: oklch(96% 0.018 272.314); --color-accent: oklch(60% 0.25 292.717); --color-accent-content: oklch(96% 0.016 293.756); --color-neutral: oklch(37% 0.044 257.287); --color-neutral-content: oklch(98% 0.003 247.858); --color-info: oklch(58% 0.158 241.966); --color-info-content: oklch(97% 0.013 236.62); --color-success: oklch(60% 0.118 184.704); --color-success-content: oklch(98% 0.014 180.72); --color-warning: oklch(66% 0.179 58.318); --color-warning-content: oklch(98% 0.022 95.277); --color-error: oklch(58% 0.253 17.585); --color-error-content: oklch(96% 0.015 12.422); --radius-selector: 0.25rem; --radius-field: 0.25rem; --radius-box: 0.5rem; --size-selector: 0.21875rem; --size-field: 0.21875rem; --border: 1.5px; --depth: 1; --noise: 0; } @plugin "../vendor/daisyui-theme" { name: "light"; default: true; prefersdark: false; color-scheme: "light"; --color-base-100: oklch(98% 0 0); --color-base-200: oklch(96% 0.001 286.375); --color-base-300: oklch(92% 0.004 286.32); --color-base-content: oklch(21% 0.006 285.885); --color-primary: oklch(70% 0.213 47.604); --color-primary-content: oklch(98% 0.016 73.684); --color-secondary: oklch(55% 0.027 264.364); --color-secondary-content: oklch(98% 0.002 247.839); --color-accent: oklch(0% 0 0); --color-accent-content: oklch(100% 0 0); --color-neutral: oklch(44% 0.017 285.786); --color-neutral-content: oklch(98% 0 0); --color-info: oklch(62% 0.214 259.815); --color-info-content: oklch(97% 0.014 254.604); --color-success: oklch(70% 0.14 182.503); --color-success-content: oklch(98% 0.014 180.72); --color-warning: oklch(66% 0.179 58.318); --color-warning-content: oklch(98% 0.022 95.277); --color-error: oklch(58% 0.253 17.585); --color-error-content: oklch(96% 0.015 12.422); --radius-selector: 0.25rem; --radius-field: 0.25rem; --radius-box: 0.5rem; --size-selector: 0.21875rem; --size-field: 0.21875rem; --border: 1.5px; --depth: 1; --noise: 0; } /* Add variants based on LiveView classes */ @custom-variant phx-click-loading (.phx-click-loading&, .phx-click-loading &); @custom-variant phx-submit-loading (.phx-submit-loading&, .phx-submit-loading &); @custom-variant phx-change-loading (.phx-change-loading&, .phx-change-loading &); /* Use the data attribute for dark mode */ @custom-variant dark (&:where([data-theme=dark], [data-theme=dark] *)); /* Make LiveView wrapper divs transparent for layout */ [data-phx-session], [data-phx-teleported-src] { display: contents } /* This file is for your main application CSS */ ================================================ FILE: installer/templates/phx_assets/app.js.eex ================================================ // If you want to use Phoenix channels, run `mix help phx.gen.channel` // to get started and then uncomment the line below. // import "./user_socket.js" // You can include dependencies in two ways. // // The simplest option is to put them in assets/vendor and // import them using relative paths: // // import "../vendor/some-package.js" // // Alternatively, you can `npm install some-package --prefix assets` and import // them using a path starting with the package name: // // import "some-package" // // If you have dependencies that try to import CSS, esbuild will generate a separate `app.css` file. // To load it, simply add a second `` to your `root.html.heex` file. <%= if @html do %> // Include phoenix_html to handle method=PUT/DELETE in forms and buttons. import "phoenix_html" // Establish Phoenix Socket and LiveView configuration. <%= @live_comment %>import {Socket} from "<%= @phoenix_js_path %>" <%= @live_comment %>import {LiveSocket} from "phoenix_live_view" <%= @live_comment %>import {hooks as colocatedHooks} from "phoenix-colocated/<%= @web_app_name %>" <%= @live_comment %>import topbar from "../vendor/topbar" <%= @live_comment %>const csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content") <%= @live_comment %>const liveSocket = new LiveSocket("/live", Socket, { <%= @live_comment %> longPollFallbackMs: 2500, <%= @live_comment %> params: {_csrf_token: csrfToken}, <%= @live_comment %> hooks: {...colocatedHooks}, <%= @live_comment %>}) // Show progress bar on live navigation and form submits <%= @live_comment %>topbar.config({barColors: {0: "#29d"}, shadowColor: "rgba(0, 0, 0, .3)"}) <%= @live_comment %>window.addEventListener("phx:page-loading-start", _info => topbar.show(300)) <%= @live_comment %>window.addEventListener("phx:page-loading-stop", _info => topbar.hide()) // connect if there are any LiveViews on the page <%= @live_comment %>liveSocket.connect() // expose liveSocket on window for web console debug logs and latency simulation: // >> liveSocket.enableDebug() // >> liveSocket.enableLatencySim(1000) // enabled for duration of browser session // >> liveSocket.disableLatencySim() <%= @live_comment %>window.liveSocket = liveSocket // The lines below enable quality of life phoenix_live_reload // development features: // // 1. stream server logs to the browser console // 2. click on elements to jump to their definitions in your code editor // <%= @live_comment %>if (process.env.NODE_ENV === "development") { <%= @live_comment %> window.addEventListener("phx:live_reload:attached", ({detail: reloader}) => { <%= @live_comment %> // Enable server log streaming to client. <%= @live_comment %> // Disable with reloader.disableServerLogs() <%= @live_comment %> reloader.enableServerLogs() <%= @live_comment %> <%= @live_comment %> // Open configured PLUG_EDITOR at file:line of the clicked element's HEEx component <%= @live_comment %> // <%= @live_comment %> // * click with "c" key pressed to open at caller location <%= @live_comment %> // * click with "d" key pressed to open at function component definition location <%= @live_comment %> let keyDown <%= @live_comment %> window.addEventListener("keydown", e => keyDown = e.key) <%= @live_comment %> window.addEventListener("keyup", _e => keyDown = null) <%= @live_comment %> window.addEventListener("click", e => { <%= @live_comment %> if(keyDown === "c"){ <%= @live_comment %> e.preventDefault() <%= @live_comment %> e.stopImmediatePropagation() <%= @live_comment %> reloader.openEditorAtCaller(e.target) <%= @live_comment %> } else if(keyDown === "d"){ <%= @live_comment %> e.preventDefault() <%= @live_comment %> e.stopImmediatePropagation() <%= @live_comment %> reloader.openEditorAtDef(e.target) <%= @live_comment %> } <%= @live_comment %> }, true) <%= @live_comment %> <%= @live_comment %> window.liveReloader = reloader <%= @live_comment %> }) <%= @live_comment %>} <%= if not @live do %> // Handle flash close document.querySelectorAll("[role=alert][data-flash]").forEach((el) => { el.addEventListener("click", () => { el.setAttribute("hidden", "") }) })<% end %><% end %> ================================================ FILE: installer/templates/phx_assets/daisyui-theme.js.eex ================================================ /** 🌼 * @license MIT * daisyUI bundle * https://daisyui.com/ */ var __defProp = Object.defineProperty; var __getOwnPropNames = Object.getOwnPropertyNames; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __hasOwnProp = Object.prototype.hasOwnProperty; var __moduleCache = /* @__PURE__ */ new WeakMap; var __toCommonJS = (from) => { var entry = __moduleCache.get(from), desc; if (entry) return entry; entry = __defProp({}, "__esModule", { value: true }); if (from && typeof from === "object" || typeof from === "function") __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable })); __moduleCache.set(from, entry); return entry; }; var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true, configurable: true, set: (newValue) => all[name] = () => newValue }); }; // packages/daisyui/theme/index.js var exports_theme = {}; __export(exports_theme, { default: () => theme_default }); module.exports = __toCommonJS(exports_theme); // packages/daisyui/functions/plugin.js var plugin = { withOptions: (pluginFunction, configFunction = () => ({})) => { const optionsFunction = (options) => { const handler = pluginFunction(options); const config = configFunction(options); return { handler, config }; }; optionsFunction.__isOptionsFunction = true; return optionsFunction; } }; // packages/daisyui/theme/object.js var object_default = { cyberpunk: { "color-scheme": "light", "--color-base-100": "oklch(94.51% 0.179 104.32)", "--color-base-200": "oklch(91.51% 0.179 104.32)", "--color-base-300": "oklch(85.51% 0.179 104.32)", "--color-base-content": "oklch(0% 0 0)", "--color-primary": "oklch(74.22% 0.209 6.35)", "--color-primary-content": "oklch(14.844% 0.041 6.35)", "--color-secondary": "oklch(83.33% 0.184 204.72)", "--color-secondary-content": "oklch(16.666% 0.036 204.72)", "--color-accent": "oklch(71.86% 0.217 310.43)", "--color-accent-content": "oklch(14.372% 0.043 310.43)", "--color-neutral": "oklch(23.04% 0.065 269.31)", "--color-neutral-content": "oklch(94.51% 0.179 104.32)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "0rem", "--radius-field": "0rem", "--radius-box": "0rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, acid: { "color-scheme": "light", "--color-base-100": "oklch(98% 0 0)", "--color-base-200": "oklch(95% 0 0)", "--color-base-300": "oklch(91% 0 0)", "--color-base-content": "oklch(0% 0 0)", "--color-primary": "oklch(71.9% 0.357 330.759)", "--color-primary-content": "oklch(14.38% 0.071 330.759)", "--color-secondary": "oklch(73.37% 0.224 48.25)", "--color-secondary-content": "oklch(14.674% 0.044 48.25)", "--color-accent": "oklch(92.78% 0.264 122.962)", "--color-accent-content": "oklch(18.556% 0.052 122.962)", "--color-neutral": "oklch(21.31% 0.128 278.68)", "--color-neutral-content": "oklch(84.262% 0.025 278.68)", "--color-info": "oklch(60.72% 0.227 252.05)", "--color-info-content": "oklch(12.144% 0.045 252.05)", "--color-success": "oklch(85.72% 0.266 158.53)", "--color-success-content": "oklch(17.144% 0.053 158.53)", "--color-warning": "oklch(91.01% 0.212 100.5)", "--color-warning-content": "oklch(18.202% 0.042 100.5)", "--color-error": "oklch(64.84% 0.293 29.349)", "--color-error-content": "oklch(12.968% 0.058 29.349)", "--radius-selector": "1rem", "--radius-field": "1rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, black: { "color-scheme": "dark", "--color-base-100": "oklch(0% 0 0)", "--color-base-200": "oklch(19% 0 0)", "--color-base-300": "oklch(22% 0 0)", "--color-base-content": "oklch(87.609% 0 0)", "--color-primary": "oklch(35% 0 0)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(35% 0 0)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(35% 0 0)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(35% 0 0)", "--color-neutral-content": "oklch(100% 0 0)", "--color-info": "oklch(45.201% 0.313 264.052)", "--color-info-content": "oklch(89.04% 0.062 264.052)", "--color-success": "oklch(51.975% 0.176 142.495)", "--color-success-content": "oklch(90.395% 0.035 142.495)", "--color-warning": "oklch(96.798% 0.211 109.769)", "--color-warning-content": "oklch(19.359% 0.042 109.769)", "--color-error": "oklch(62.795% 0.257 29.233)", "--color-error-content": "oklch(12.559% 0.051 29.233)", "--radius-selector": "0rem", "--radius-field": "0rem", "--radius-box": "0rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, dark: { "color-scheme": "dark", "--color-base-100": "oklch(25.33% 0.016 252.42)", "--color-base-200": "oklch(23.26% 0.014 253.1)", "--color-base-300": "oklch(21.15% 0.012 254.09)", "--color-base-content": "oklch(97.807% 0.029 256.847)", "--color-primary": "oklch(58% 0.233 277.117)", "--color-primary-content": "oklch(96% 0.018 272.314)", "--color-secondary": "oklch(65% 0.241 354.308)", "--color-secondary-content": "oklch(94% 0.028 342.258)", "--color-accent": "oklch(77% 0.152 181.912)", "--color-accent-content": "oklch(38% 0.063 188.416)", "--color-neutral": "oklch(14% 0.005 285.823)", "--color-neutral-content": "oklch(92% 0.004 286.32)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(76% 0.177 163.223)", "--color-success-content": "oklch(37% 0.077 168.94)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(71% 0.194 13.428)", "--color-error-content": "oklch(27% 0.105 12.094)", "--radius-selector": "0.5rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, light: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(98% 0 0)", "--color-base-300": "oklch(95% 0 0)", "--color-base-content": "oklch(21% 0.006 285.885)", "--color-primary": "oklch(45% 0.24 277.023)", "--color-primary-content": "oklch(93% 0.034 272.788)", "--color-secondary": "oklch(65% 0.241 354.308)", "--color-secondary-content": "oklch(94% 0.028 342.258)", "--color-accent": "oklch(77% 0.152 181.912)", "--color-accent-content": "oklch(38% 0.063 188.416)", "--color-neutral": "oklch(14% 0.005 285.823)", "--color-neutral-content": "oklch(92% 0.004 286.32)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(76% 0.177 163.223)", "--color-success-content": "oklch(37% 0.077 168.94)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(71% 0.194 13.428)", "--color-error-content": "oklch(27% 0.105 12.094)", "--radius-selector": "0.5rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, luxury: { "color-scheme": "dark", "--color-base-100": "oklch(14.076% 0.004 285.822)", "--color-base-200": "oklch(20.219% 0.004 308.229)", "--color-base-300": "oklch(23.219% 0.004 308.229)", "--color-base-content": "oklch(75.687% 0.123 76.89)", "--color-primary": "oklch(100% 0 0)", "--color-primary-content": "oklch(20% 0 0)", "--color-secondary": "oklch(27.581% 0.064 261.069)", "--color-secondary-content": "oklch(85.516% 0.012 261.069)", "--color-accent": "oklch(36.674% 0.051 338.825)", "--color-accent-content": "oklch(87.334% 0.01 338.825)", "--color-neutral": "oklch(24.27% 0.057 59.825)", "--color-neutral-content": "oklch(93.203% 0.089 90.861)", "--color-info": "oklch(79.061% 0.121 237.133)", "--color-info-content": "oklch(15.812% 0.024 237.133)", "--color-success": "oklch(78.119% 0.192 132.154)", "--color-success-content": "oklch(15.623% 0.038 132.154)", "--color-warning": "oklch(86.127% 0.136 102.891)", "--color-warning-content": "oklch(17.225% 0.027 102.891)", "--color-error": "oklch(71.753% 0.176 22.568)", "--color-error-content": "oklch(14.35% 0.035 22.568)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, dracula: { "color-scheme": "dark", "--color-base-100": "oklch(28.822% 0.022 277.508)", "--color-base-200": "oklch(26.805% 0.02 277.508)", "--color-base-300": "oklch(24.787% 0.019 277.508)", "--color-base-content": "oklch(97.747% 0.007 106.545)", "--color-primary": "oklch(75.461% 0.183 346.812)", "--color-primary-content": "oklch(15.092% 0.036 346.812)", "--color-secondary": "oklch(74.202% 0.148 301.883)", "--color-secondary-content": "oklch(14.84% 0.029 301.883)", "--color-accent": "oklch(83.392% 0.124 66.558)", "--color-accent-content": "oklch(16.678% 0.024 66.558)", "--color-neutral": "oklch(39.445% 0.032 275.524)", "--color-neutral-content": "oklch(87.889% 0.006 275.524)", "--color-info": "oklch(88.263% 0.093 212.846)", "--color-info-content": "oklch(17.652% 0.018 212.846)", "--color-success": "oklch(87.099% 0.219 148.024)", "--color-success-content": "oklch(17.419% 0.043 148.024)", "--color-warning": "oklch(95.533% 0.134 112.757)", "--color-warning-content": "oklch(19.106% 0.026 112.757)", "--color-error": "oklch(68.22% 0.206 24.43)", "--color-error-content": "oklch(13.644% 0.041 24.43)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, retro: { "color-scheme": "light", "--color-base-100": "oklch(91.637% 0.034 90.515)", "--color-base-200": "oklch(88.272% 0.049 91.774)", "--color-base-300": "oklch(84.133% 0.065 90.856)", "--color-base-content": "oklch(41% 0.112 45.904)", "--color-primary": "oklch(80% 0.114 19.571)", "--color-primary-content": "oklch(39% 0.141 25.723)", "--color-secondary": "oklch(92% 0.084 155.995)", "--color-secondary-content": "oklch(44% 0.119 151.328)", "--color-accent": "oklch(68% 0.162 75.834)", "--color-accent-content": "oklch(41% 0.112 45.904)", "--color-neutral": "oklch(44% 0.011 73.639)", "--color-neutral-content": "oklch(86% 0.005 56.366)", "--color-info": "oklch(58% 0.158 241.966)", "--color-info-content": "oklch(96% 0.059 95.617)", "--color-success": "oklch(51% 0.096 186.391)", "--color-success-content": "oklch(96% 0.059 95.617)", "--color-warning": "oklch(64% 0.222 41.116)", "--color-warning-content": "oklch(96% 0.059 95.617)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(40% 0.123 38.172)", "--radius-selector": "0.25rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, lofi: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97% 0 0)", "--color-base-300": "oklch(94% 0 0)", "--color-base-content": "oklch(0% 0 0)", "--color-primary": "oklch(15.906% 0 0)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(21.455% 0.001 17.278)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(26.861% 0 0)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(0% 0 0)", "--color-neutral-content": "oklch(100% 0 0)", "--color-info": "oklch(79.54% 0.103 205.9)", "--color-info-content": "oklch(15.908% 0.02 205.9)", "--color-success": "oklch(90.13% 0.153 164.14)", "--color-success-content": "oklch(18.026% 0.03 164.14)", "--color-warning": "oklch(88.37% 0.135 79.94)", "--color-warning-content": "oklch(17.674% 0.027 79.94)", "--color-error": "oklch(78.66% 0.15 28.47)", "--color-error-content": "oklch(15.732% 0.03 28.47)", "--radius-selector": "2rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, valentine: { "color-scheme": "light", "--color-base-100": "oklch(97% 0.014 343.198)", "--color-base-200": "oklch(94% 0.028 342.258)", "--color-base-300": "oklch(89% 0.061 343.231)", "--color-base-content": "oklch(52% 0.223 3.958)", "--color-primary": "oklch(65% 0.241 354.308)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(62% 0.265 303.9)", "--color-secondary-content": "oklch(97% 0.014 308.299)", "--color-accent": "oklch(82% 0.111 230.318)", "--color-accent-content": "oklch(39% 0.09 240.876)", "--color-neutral": "oklch(40% 0.153 2.432)", "--color-neutral-content": "oklch(89% 0.061 343.231)", "--color-info": "oklch(86% 0.127 207.078)", "--color-info-content": "oklch(44% 0.11 240.79)", "--color-success": "oklch(84% 0.143 164.978)", "--color-success-content": "oklch(43% 0.095 166.913)", "--color-warning": "oklch(75% 0.183 55.934)", "--color-warning-content": "oklch(26% 0.079 36.259)", "--color-error": "oklch(63% 0.237 25.331)", "--color-error-content": "oklch(97% 0.013 17.38)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, nord: { "color-scheme": "light", "--color-base-100": "oklch(95.127% 0.007 260.731)", "--color-base-200": "oklch(93.299% 0.01 261.788)", "--color-base-300": "oklch(89.925% 0.016 262.749)", "--color-base-content": "oklch(32.437% 0.022 264.182)", "--color-primary": "oklch(59.435% 0.077 254.027)", "--color-primary-content": "oklch(11.887% 0.015 254.027)", "--color-secondary": "oklch(69.651% 0.059 248.687)", "--color-secondary-content": "oklch(13.93% 0.011 248.687)", "--color-accent": "oklch(77.464% 0.062 217.469)", "--color-accent-content": "oklch(15.492% 0.012 217.469)", "--color-neutral": "oklch(45.229% 0.035 264.131)", "--color-neutral-content": "oklch(89.925% 0.016 262.749)", "--color-info": "oklch(69.207% 0.062 332.664)", "--color-info-content": "oklch(13.841% 0.012 332.664)", "--color-success": "oklch(76.827% 0.074 131.063)", "--color-success-content": "oklch(15.365% 0.014 131.063)", "--color-warning": "oklch(85.486% 0.089 84.093)", "--color-warning-content": "oklch(17.097% 0.017 84.093)", "--color-error": "oklch(60.61% 0.12 15.341)", "--color-error-content": "oklch(12.122% 0.024 15.341)", "--radius-selector": "1rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, lemonade: { "color-scheme": "light", "--color-base-100": "oklch(98.71% 0.02 123.72)", "--color-base-200": "oklch(91.8% 0.018 123.72)", "--color-base-300": "oklch(84.89% 0.017 123.72)", "--color-base-content": "oklch(19.742% 0.004 123.72)", "--color-primary": "oklch(58.92% 0.199 134.6)", "--color-primary-content": "oklch(11.784% 0.039 134.6)", "--color-secondary": "oklch(77.75% 0.196 111.09)", "--color-secondary-content": "oklch(15.55% 0.039 111.09)", "--color-accent": "oklch(85.39% 0.201 100.73)", "--color-accent-content": "oklch(17.078% 0.04 100.73)", "--color-neutral": "oklch(30.98% 0.075 108.6)", "--color-neutral-content": "oklch(86.196% 0.015 108.6)", "--color-info": "oklch(86.19% 0.047 224.14)", "--color-info-content": "oklch(17.238% 0.009 224.14)", "--color-success": "oklch(86.19% 0.047 157.85)", "--color-success-content": "oklch(17.238% 0.009 157.85)", "--color-warning": "oklch(86.19% 0.047 102.15)", "--color-warning-content": "oklch(17.238% 0.009 102.15)", "--color-error": "oklch(86.19% 0.047 25.85)", "--color-error-content": "oklch(17.238% 0.009 25.85)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, garden: { "color-scheme": "light", "--color-base-100": "oklch(92.951% 0.002 17.197)", "--color-base-200": "oklch(86.445% 0.002 17.197)", "--color-base-300": "oklch(79.938% 0.001 17.197)", "--color-base-content": "oklch(16.961% 0.001 17.32)", "--color-primary": "oklch(62.45% 0.278 3.836)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(48.495% 0.11 355.095)", "--color-secondary-content": "oklch(89.699% 0.022 355.095)", "--color-accent": "oklch(56.273% 0.054 154.39)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(24.155% 0.049 89.07)", "--color-neutral-content": "oklch(92.951% 0.002 17.197)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, aqua: { "color-scheme": "dark", "--color-base-100": "oklch(37% 0.146 265.522)", "--color-base-200": "oklch(28% 0.091 267.935)", "--color-base-300": "oklch(22% 0.091 267.935)", "--color-base-content": "oklch(90% 0.058 230.902)", "--color-primary": "oklch(85.661% 0.144 198.645)", "--color-primary-content": "oklch(40.124% 0.068 197.603)", "--color-secondary": "oklch(60.682% 0.108 309.782)", "--color-secondary-content": "oklch(96% 0.016 293.756)", "--color-accent": "oklch(93.426% 0.102 94.555)", "--color-accent-content": "oklch(18.685% 0.02 94.555)", "--color-neutral": "oklch(27% 0.146 265.522)", "--color-neutral-content": "oklch(80% 0.146 265.522)", "--color-info": "oklch(54.615% 0.215 262.88)", "--color-info-content": "oklch(90.923% 0.043 262.88)", "--color-success": "oklch(62.705% 0.169 149.213)", "--color-success-content": "oklch(12.541% 0.033 149.213)", "--color-warning": "oklch(66.584% 0.157 58.318)", "--color-warning-content": "oklch(27% 0.077 45.635)", "--color-error": "oklch(73.95% 0.19 27.33)", "--color-error-content": "oklch(14.79% 0.038 27.33)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, corporate: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(93% 0 0)", "--color-base-300": "oklch(86% 0 0)", "--color-base-content": "oklch(22.389% 0.031 278.072)", "--color-primary": "oklch(58% 0.158 241.966)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(55% 0.046 257.417)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(60% 0.118 184.704)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(0% 0 0)", "--color-neutral-content": "oklch(100% 0 0)", "--color-info": "oklch(60% 0.126 221.723)", "--color-info-content": "oklch(100% 0 0)", "--color-success": "oklch(62% 0.194 149.214)", "--color-success-content": "oklch(100% 0 0)", "--color-warning": "oklch(85% 0.199 91.936)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "0.25rem", "--radius-field": "0.25rem", "--radius-box": "0.25rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, pastel: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(98.462% 0.001 247.838)", "--color-base-300": "oklch(92.462% 0.001 247.838)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(90% 0.063 306.703)", "--color-primary-content": "oklch(49% 0.265 301.924)", "--color-secondary": "oklch(89% 0.058 10.001)", "--color-secondary-content": "oklch(51% 0.222 16.935)", "--color-accent": "oklch(90% 0.093 164.15)", "--color-accent-content": "oklch(50% 0.118 165.612)", "--color-neutral": "oklch(55% 0.046 257.417)", "--color-neutral-content": "oklch(92% 0.013 255.508)", "--color-info": "oklch(86% 0.127 207.078)", "--color-info-content": "oklch(52% 0.105 223.128)", "--color-success": "oklch(87% 0.15 154.449)", "--color-success-content": "oklch(52% 0.154 150.069)", "--color-warning": "oklch(83% 0.128 66.29)", "--color-warning-content": "oklch(55% 0.195 38.402)", "--color-error": "oklch(80% 0.114 19.571)", "--color-error-content": "oklch(50% 0.213 27.518)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "0", "--noise": "0" }, bumblebee: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97% 0 0)", "--color-base-300": "oklch(92% 0 0)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(85% 0.199 91.936)", "--color-primary-content": "oklch(42% 0.095 57.708)", "--color-secondary": "oklch(75% 0.183 55.934)", "--color-secondary-content": "oklch(40% 0.123 38.172)", "--color-accent": "oklch(0% 0 0)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(37% 0.01 67.558)", "--color-neutral-content": "oklch(92% 0.003 48.717)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(39% 0.09 240.876)", "--color-success": "oklch(76% 0.177 163.223)", "--color-success-content": "oklch(37% 0.077 168.94)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(39% 0.141 25.723)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, coffee: { "color-scheme": "dark", "--color-base-100": "oklch(24% 0.023 329.708)", "--color-base-200": "oklch(21% 0.021 329.708)", "--color-base-300": "oklch(16% 0.019 329.708)", "--color-base-content": "oklch(72.354% 0.092 79.129)", "--color-primary": "oklch(71.996% 0.123 62.756)", "--color-primary-content": "oklch(14.399% 0.024 62.756)", "--color-secondary": "oklch(34.465% 0.029 199.194)", "--color-secondary-content": "oklch(86.893% 0.005 199.194)", "--color-accent": "oklch(42.621% 0.074 224.389)", "--color-accent-content": "oklch(88.524% 0.014 224.389)", "--color-neutral": "oklch(16.51% 0.015 326.261)", "--color-neutral-content": "oklch(83.302% 0.003 326.261)", "--color-info": "oklch(79.49% 0.063 184.558)", "--color-info-content": "oklch(15.898% 0.012 184.558)", "--color-success": "oklch(74.722% 0.072 131.116)", "--color-success-content": "oklch(14.944% 0.014 131.116)", "--color-warning": "oklch(88.15% 0.14 87.722)", "--color-warning-content": "oklch(17.63% 0.028 87.722)", "--color-error": "oklch(77.318% 0.128 31.871)", "--color-error-content": "oklch(15.463% 0.025 31.871)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, silk: { "color-scheme": "light", "--color-base-100": "oklch(97% 0.0035 67.78)", "--color-base-200": "oklch(95% 0.0081 61.42)", "--color-base-300": "oklch(90% 0.0081 61.42)", "--color-base-content": "oklch(40% 0.0081 61.42)", "--color-primary": "oklch(23.27% 0.0249 284.3)", "--color-primary-content": "oklch(94.22% 0.2505 117.44)", "--color-secondary": "oklch(23.27% 0.0249 284.3)", "--color-secondary-content": "oklch(73.92% 0.2135 50.94)", "--color-accent": "oklch(23.27% 0.0249 284.3)", "--color-accent-content": "oklch(88.92% 0.2061 189.9)", "--color-neutral": "oklch(20% 0 0)", "--color-neutral-content": "oklch(80% 0.0081 61.42)", "--color-info": "oklch(80.39% 0.1148 241.68)", "--color-info-content": "oklch(30.39% 0.1148 241.68)", "--color-success": "oklch(83.92% 0.0901 136.87)", "--color-success-content": "oklch(23.92% 0.0901 136.87)", "--color-warning": "oklch(83.92% 0.1085 80)", "--color-warning-content": "oklch(43.92% 0.1085 80)", "--color-error": "oklch(75.1% 0.1814 22.37)", "--color-error-content": "oklch(35.1% 0.1814 22.37)", "--radius-selector": "2rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "1", "--noise": "0" }, sunset: { "color-scheme": "dark", "--color-base-100": "oklch(22% 0.019 237.69)", "--color-base-200": "oklch(20% 0.019 237.69)", "--color-base-300": "oklch(18% 0.019 237.69)", "--color-base-content": "oklch(77.383% 0.043 245.096)", "--color-primary": "oklch(74.703% 0.158 39.947)", "--color-primary-content": "oklch(14.94% 0.031 39.947)", "--color-secondary": "oklch(72.537% 0.177 2.72)", "--color-secondary-content": "oklch(14.507% 0.035 2.72)", "--color-accent": "oklch(71.294% 0.166 299.844)", "--color-accent-content": "oklch(14.258% 0.033 299.844)", "--color-neutral": "oklch(26% 0.019 237.69)", "--color-neutral-content": "oklch(70% 0.019 237.69)", "--color-info": "oklch(85.559% 0.085 206.015)", "--color-info-content": "oklch(17.111% 0.017 206.015)", "--color-success": "oklch(85.56% 0.085 144.778)", "--color-success-content": "oklch(17.112% 0.017 144.778)", "--color-warning": "oklch(85.569% 0.084 74.427)", "--color-warning-content": "oklch(17.113% 0.016 74.427)", "--color-error": "oklch(85.511% 0.078 16.886)", "--color-error-content": "oklch(17.102% 0.015 16.886)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, synthwave: { "color-scheme": "dark", "--color-base-100": "oklch(15% 0.09 281.288)", "--color-base-200": "oklch(20% 0.09 281.288)", "--color-base-300": "oklch(25% 0.09 281.288)", "--color-base-content": "oklch(78% 0.115 274.713)", "--color-primary": "oklch(71% 0.202 349.761)", "--color-primary-content": "oklch(28% 0.109 3.907)", "--color-secondary": "oklch(82% 0.111 230.318)", "--color-secondary-content": "oklch(29% 0.066 243.157)", "--color-accent": "oklch(75% 0.183 55.934)", "--color-accent-content": "oklch(26% 0.079 36.259)", "--color-neutral": "oklch(45% 0.24 277.023)", "--color-neutral-content": "oklch(87% 0.065 274.039)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(77% 0.152 181.912)", "--color-success-content": "oklch(27% 0.046 192.524)", "--color-warning": "oklch(90% 0.182 98.111)", "--color-warning-content": "oklch(42% 0.095 57.708)", "--color-error": "oklch(73.7% 0.121 32.639)", "--color-error-content": "oklch(23.501% 0.096 290.329)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, dim: { "color-scheme": "dark", "--color-base-100": "oklch(30.857% 0.023 264.149)", "--color-base-200": "oklch(28.036% 0.019 264.182)", "--color-base-300": "oklch(26.346% 0.018 262.177)", "--color-base-content": "oklch(82.901% 0.031 222.959)", "--color-primary": "oklch(86.133% 0.141 139.549)", "--color-primary-content": "oklch(17.226% 0.028 139.549)", "--color-secondary": "oklch(73.375% 0.165 35.353)", "--color-secondary-content": "oklch(14.675% 0.033 35.353)", "--color-accent": "oklch(74.229% 0.133 311.379)", "--color-accent-content": "oklch(14.845% 0.026 311.379)", "--color-neutral": "oklch(24.731% 0.02 264.094)", "--color-neutral-content": "oklch(82.901% 0.031 222.959)", "--color-info": "oklch(86.078% 0.142 206.182)", "--color-info-content": "oklch(17.215% 0.028 206.182)", "--color-success": "oklch(86.171% 0.142 166.534)", "--color-success-content": "oklch(17.234% 0.028 166.534)", "--color-warning": "oklch(86.163% 0.142 94.818)", "--color-warning-content": "oklch(17.232% 0.028 94.818)", "--color-error": "oklch(82.418% 0.099 33.756)", "--color-error-content": "oklch(16.483% 0.019 33.756)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, abyss: { "color-scheme": "dark", "--color-base-100": "oklch(20% 0.08 209)", "--color-base-200": "oklch(15% 0.08 209)", "--color-base-300": "oklch(10% 0.08 209)", "--color-base-content": "oklch(90% 0.076 70.697)", "--color-primary": "oklch(92% 0.2653 125)", "--color-primary-content": "oklch(50% 0.2653 125)", "--color-secondary": "oklch(83.27% 0.0764 298.3)", "--color-secondary-content": "oklch(43.27% 0.0764 298.3)", "--color-accent": "oklch(43% 0 0)", "--color-accent-content": "oklch(98% 0 0)", "--color-neutral": "oklch(30% 0.08 209)", "--color-neutral-content": "oklch(90% 0.076 70.697)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(79% 0.209 151.711)", "--color-success-content": "oklch(26% 0.065 152.934)", "--color-warning": "oklch(84.8% 0.1962 84.62)", "--color-warning-content": "oklch(44.8% 0.1962 84.62)", "--color-error": "oklch(65% 0.1985 24.22)", "--color-error-content": "oklch(27% 0.1985 24.22)", "--radius-selector": "2rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, forest: { "color-scheme": "dark", "--color-base-100": "oklch(20.84% 0.008 17.911)", "--color-base-200": "oklch(18.522% 0.007 17.911)", "--color-base-300": "oklch(16.203% 0.007 17.911)", "--color-base-content": "oklch(83.768% 0.001 17.911)", "--color-primary": "oklch(68.628% 0.185 148.958)", "--color-primary-content": "oklch(0% 0 0)", "--color-secondary": "oklch(69.776% 0.135 168.327)", "--color-secondary-content": "oklch(13.955% 0.027 168.327)", "--color-accent": "oklch(70.628% 0.119 185.713)", "--color-accent-content": "oklch(14.125% 0.023 185.713)", "--color-neutral": "oklch(30.698% 0.039 171.364)", "--color-neutral-content": "oklch(86.139% 0.007 171.364)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, night: { "color-scheme": "dark", "--color-base-100": "oklch(20.768% 0.039 265.754)", "--color-base-200": "oklch(19.314% 0.037 265.754)", "--color-base-300": "oklch(17.86% 0.034 265.754)", "--color-base-content": "oklch(84.153% 0.007 265.754)", "--color-primary": "oklch(75.351% 0.138 232.661)", "--color-primary-content": "oklch(15.07% 0.027 232.661)", "--color-secondary": "oklch(68.011% 0.158 276.934)", "--color-secondary-content": "oklch(13.602% 0.031 276.934)", "--color-accent": "oklch(72.36% 0.176 350.048)", "--color-accent-content": "oklch(14.472% 0.035 350.048)", "--color-neutral": "oklch(27.949% 0.036 260.03)", "--color-neutral-content": "oklch(85.589% 0.007 260.03)", "--color-info": "oklch(68.455% 0.148 237.251)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(78.452% 0.132 181.911)", "--color-success-content": "oklch(15.69% 0.026 181.911)", "--color-warning": "oklch(83.242% 0.139 82.95)", "--color-warning-content": "oklch(16.648% 0.027 82.95)", "--color-error": "oklch(71.785% 0.17 13.118)", "--color-error-content": "oklch(14.357% 0.034 13.118)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, caramellatte: { "color-scheme": "light", "--color-base-100": "oklch(98% 0.016 73.684)", "--color-base-200": "oklch(95% 0.038 75.164)", "--color-base-300": "oklch(90% 0.076 70.697)", "--color-base-content": "oklch(40% 0.123 38.172)", "--color-primary": "oklch(0% 0 0)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(22.45% 0.075 37.85)", "--color-secondary-content": "oklch(90% 0.076 70.697)", "--color-accent": "oklch(46.44% 0.111 37.85)", "--color-accent-content": "oklch(90% 0.076 70.697)", "--color-neutral": "oklch(55% 0.195 38.402)", "--color-neutral-content": "oklch(98% 0.016 73.684)", "--color-info": "oklch(42% 0.199 265.638)", "--color-info-content": "oklch(90% 0.076 70.697)", "--color-success": "oklch(43% 0.095 166.913)", "--color-success-content": "oklch(90% 0.076 70.697)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(39% 0.141 25.723)", "--radius-selector": "2rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "1", "--noise": "1" }, autumn: { "color-scheme": "light", "--color-base-100": "oklch(95.814% 0 0)", "--color-base-200": "oklch(89.107% 0 0)", "--color-base-300": "oklch(82.4% 0 0)", "--color-base-content": "oklch(19.162% 0 0)", "--color-primary": "oklch(40.723% 0.161 17.53)", "--color-primary-content": "oklch(88.144% 0.032 17.53)", "--color-secondary": "oklch(61.676% 0.169 23.865)", "--color-secondary-content": "oklch(12.335% 0.033 23.865)", "--color-accent": "oklch(73.425% 0.094 60.729)", "--color-accent-content": "oklch(14.685% 0.018 60.729)", "--color-neutral": "oklch(54.367% 0.037 51.902)", "--color-neutral-content": "oklch(90.873% 0.007 51.902)", "--color-info": "oklch(69.224% 0.097 207.284)", "--color-info-content": "oklch(13.844% 0.019 207.284)", "--color-success": "oklch(60.995% 0.08 174.616)", "--color-success-content": "oklch(12.199% 0.016 174.616)", "--color-warning": "oklch(70.081% 0.164 56.844)", "--color-warning-content": "oklch(14.016% 0.032 56.844)", "--color-error": "oklch(53.07% 0.241 24.16)", "--color-error-content": "oklch(90.614% 0.048 24.16)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, emerald: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(93% 0 0)", "--color-base-300": "oklch(86% 0 0)", "--color-base-content": "oklch(35.519% 0.032 262.988)", "--color-primary": "oklch(76.662% 0.135 153.45)", "--color-primary-content": "oklch(33.387% 0.04 162.24)", "--color-secondary": "oklch(61.302% 0.202 261.294)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(72.772% 0.149 33.2)", "--color-accent-content": "oklch(0% 0 0)", "--color-neutral": "oklch(35.519% 0.032 262.988)", "--color-neutral-content": "oklch(98.462% 0.001 247.838)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, cupcake: { "color-scheme": "light", "--color-base-100": "oklch(97.788% 0.004 56.375)", "--color-base-200": "oklch(93.982% 0.007 61.449)", "--color-base-300": "oklch(91.586% 0.006 53.44)", "--color-base-content": "oklch(23.574% 0.066 313.189)", "--color-primary": "oklch(85% 0.138 181.071)", "--color-primary-content": "oklch(43% 0.078 188.216)", "--color-secondary": "oklch(89% 0.061 343.231)", "--color-secondary-content": "oklch(45% 0.187 3.815)", "--color-accent": "oklch(90% 0.076 70.697)", "--color-accent-content": "oklch(47% 0.157 37.304)", "--color-neutral": "oklch(27% 0.006 286.033)", "--color-neutral-content": "oklch(92% 0.004 286.32)", "--color-info": "oklch(68% 0.169 237.323)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(69% 0.17 162.48)", "--color-success-content": "oklch(26% 0.051 172.552)", "--color-warning": "oklch(79% 0.184 86.047)", "--color-warning-content": "oklch(28% 0.066 53.813)", "--color-error": "oklch(64% 0.246 16.439)", "--color-error-content": "oklch(27% 0.105 12.094)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "1", "--noise": "0" }, cmyk: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(95% 0 0)", "--color-base-300": "oklch(90% 0 0)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(71.772% 0.133 239.443)", "--color-primary-content": "oklch(14.354% 0.026 239.443)", "--color-secondary": "oklch(64.476% 0.202 359.339)", "--color-secondary-content": "oklch(12.895% 0.04 359.339)", "--color-accent": "oklch(94.228% 0.189 105.306)", "--color-accent-content": "oklch(18.845% 0.037 105.306)", "--color-neutral": "oklch(21.778% 0 0)", "--color-neutral-content": "oklch(84.355% 0 0)", "--color-info": "oklch(68.475% 0.094 217.284)", "--color-info-content": "oklch(13.695% 0.018 217.284)", "--color-success": "oklch(46.949% 0.162 321.406)", "--color-success-content": "oklch(89.389% 0.032 321.406)", "--color-warning": "oklch(71.236% 0.159 52.023)", "--color-warning-content": "oklch(14.247% 0.031 52.023)", "--color-error": "oklch(62.013% 0.208 28.717)", "--color-error-content": "oklch(12.402% 0.041 28.717)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, business: { "color-scheme": "dark", "--color-base-100": "oklch(24.353% 0 0)", "--color-base-200": "oklch(22.648% 0 0)", "--color-base-300": "oklch(20.944% 0 0)", "--color-base-content": "oklch(84.87% 0 0)", "--color-primary": "oklch(41.703% 0.099 251.473)", "--color-primary-content": "oklch(88.34% 0.019 251.473)", "--color-secondary": "oklch(64.092% 0.027 229.389)", "--color-secondary-content": "oklch(12.818% 0.005 229.389)", "--color-accent": "oklch(67.271% 0.167 35.791)", "--color-accent-content": "oklch(13.454% 0.033 35.791)", "--color-neutral": "oklch(27.441% 0.013 253.041)", "--color-neutral-content": "oklch(85.488% 0.002 253.041)", "--color-info": "oklch(62.616% 0.143 240.033)", "--color-info-content": "oklch(12.523% 0.028 240.033)", "--color-success": "oklch(70.226% 0.094 156.596)", "--color-success-content": "oklch(14.045% 0.018 156.596)", "--color-warning": "oklch(77.482% 0.115 81.519)", "--color-warning-content": "oklch(15.496% 0.023 81.519)", "--color-error": "oklch(51.61% 0.146 29.674)", "--color-error-content": "oklch(90.322% 0.029 29.674)", "--radius-selector": "0rem", "--radius-field": "0.25rem", "--radius-box": "0.25rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, winter: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97.466% 0.011 259.822)", "--color-base-300": "oklch(93.268% 0.016 262.751)", "--color-base-content": "oklch(41.886% 0.053 255.824)", "--color-primary": "oklch(56.86% 0.255 257.57)", "--color-primary-content": "oklch(91.372% 0.051 257.57)", "--color-secondary": "oklch(42.551% 0.161 282.339)", "--color-secondary-content": "oklch(88.51% 0.032 282.339)", "--color-accent": "oklch(59.939% 0.191 335.171)", "--color-accent-content": "oklch(11.988% 0.038 335.171)", "--color-neutral": "oklch(19.616% 0.063 257.651)", "--color-neutral-content": "oklch(83.923% 0.012 257.651)", "--color-info": "oklch(88.127% 0.085 214.515)", "--color-info-content": "oklch(17.625% 0.017 214.515)", "--color-success": "oklch(80.494% 0.077 197.823)", "--color-success-content": "oklch(16.098% 0.015 197.823)", "--color-warning": "oklch(89.172% 0.045 71.47)", "--color-warning-content": "oklch(17.834% 0.009 71.47)", "--color-error": "oklch(73.092% 0.11 20.076)", "--color-error-content": "oklch(14.618% 0.022 20.076)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, halloween: { "color-scheme": "dark", "--color-base-100": "oklch(21% 0.006 56.043)", "--color-base-200": "oklch(14% 0.004 49.25)", "--color-base-300": "oklch(0% 0 0)", "--color-base-content": "oklch(84.955% 0 0)", "--color-primary": "oklch(77.48% 0.204 60.62)", "--color-primary-content": "oklch(19.693% 0.004 196.779)", "--color-secondary": "oklch(45.98% 0.248 305.03)", "--color-secondary-content": "oklch(89.196% 0.049 305.03)", "--color-accent": "oklch(64.8% 0.223 136.073)", "--color-accent-content": "oklch(0% 0 0)", "--color-neutral": "oklch(24.371% 0.046 65.681)", "--color-neutral-content": "oklch(84.874% 0.009 65.681)", "--color-info": "oklch(54.615% 0.215 262.88)", "--color-info-content": "oklch(90.923% 0.043 262.88)", "--color-success": "oklch(62.705% 0.169 149.213)", "--color-success-content": "oklch(12.541% 0.033 149.213)", "--color-warning": "oklch(66.584% 0.157 58.318)", "--color-warning-content": "oklch(13.316% 0.031 58.318)", "--color-error": "oklch(65.72% 0.199 27.33)", "--color-error-content": "oklch(13.144% 0.039 27.33)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, fantasy: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(93% 0 0)", "--color-base-300": "oklch(86% 0 0)", "--color-base-content": "oklch(27.807% 0.029 256.847)", "--color-primary": "oklch(37.45% 0.189 325.02)", "--color-primary-content": "oklch(87.49% 0.037 325.02)", "--color-secondary": "oklch(53.92% 0.162 241.36)", "--color-secondary-content": "oklch(90.784% 0.032 241.36)", "--color-accent": "oklch(75.98% 0.204 56.72)", "--color-accent-content": "oklch(15.196% 0.04 56.72)", "--color-neutral": "oklch(27.807% 0.029 256.847)", "--color-neutral-content": "oklch(85.561% 0.005 256.847)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, wireframe: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97% 0 0)", "--color-base-300": "oklch(94% 0 0)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(87% 0 0)", "--color-primary-content": "oklch(26% 0 0)", "--color-secondary": "oklch(87% 0 0)", "--color-secondary-content": "oklch(26% 0 0)", "--color-accent": "oklch(87% 0 0)", "--color-accent-content": "oklch(26% 0 0)", "--color-neutral": "oklch(87% 0 0)", "--color-neutral-content": "oklch(26% 0 0)", "--color-info": "oklch(44% 0.11 240.79)", "--color-info-content": "oklch(90% 0.058 230.902)", "--color-success": "oklch(43% 0.095 166.913)", "--color-success-content": "oklch(90% 0.093 164.15)", "--color-warning": "oklch(47% 0.137 46.201)", "--color-warning-content": "oklch(92% 0.12 95.746)", "--color-error": "oklch(44% 0.177 26.899)", "--color-error-content": "oklch(88% 0.062 18.334)", "--radius-selector": "0rem", "--radius-field": "0.25rem", "--radius-box": "0.25rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" } }; // packages/daisyui/theme/index.js var theme_default = plugin.withOptions((options = {}) => { return ({ addBase }) => { const { name = "custom-theme", default: isDefault = false, prefersdark = false, "color-scheme": colorScheme = "normal", root = ":root", ...customThemeTokens } = options; let selector = `${root}:has(input.theme-controller[value=${name}]:checked),[data-theme="${name}"]`; if (isDefault) { selector = `:where(${root}),${selector}`; } let themeTokens = { ...customThemeTokens }; if (object_default[name]) { const builtinTheme = object_default[name]; themeTokens = { ...builtinTheme, ...customThemeTokens, "color-scheme": colorScheme || builtinTheme.colorScheme }; } const baseStyles = { [selector]: { "color-scheme": themeTokens["color-scheme"] || colorScheme, ...themeTokens } }; if (prefersdark) { addBase({ "@media (prefers-color-scheme: dark)": { [root]: baseStyles[selector] } }); } addBase(baseStyles); }; }); /* MIT License Copyright (c) 2020 Pouya Saadeghi – https://daisyui.com Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ ================================================ FILE: installer/templates/phx_assets/daisyui.js.eex ================================================ /** 🌼 * @license MIT * daisyUI bundle * https://daisyui.com/ */ var __defProp = Object.defineProperty; var __getOwnPropNames = Object.getOwnPropertyNames; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __hasOwnProp = Object.prototype.hasOwnProperty; var __moduleCache = /* @__PURE__ */ new WeakMap; var __toCommonJS = (from) => { var entry = __moduleCache.get(from), desc; if (entry) return entry; entry = __defProp({}, "__esModule", { value: true }); if (from && typeof from === "object" || typeof from === "function") __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable })); __moduleCache.set(from, entry); return entry; }; var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true, configurable: true, set: (newValue) => all[name] = () => newValue }); }; // packages/daisyui/index.js var exports_daisyui = {}; __export(exports_daisyui, { default: () => daisyui_default }); module.exports = __toCommonJS(exports_daisyui); // packages/daisyui/functions/themeOrder.js var themeOrder_default = [ "light", "dark", "cupcake", "bumblebee", "emerald", "corporate", "synthwave", "retro", "cyberpunk", "valentine", "halloween", "garden", "forest", "aqua", "lofi", "pastel", "fantasy", "wireframe", "black", "luxury", "dracula", "cmyk", "autumn", "business", "acid", "lemonade", "night", "coffee", "winter", "dim", "nord", "sunset", "caramellatte", "abyss", "silk" ]; // packages/daisyui/functions/pluginOptionsHandler.js var pluginOptionsHandler = (() => { let firstRun = true; return (options, addBase, themesObject, packageVersion) => { const { logs = true, root = ":root", themes = ["light --default", "dark --prefersdark"], include, exclude, prefix = "" } = options || {}; if (logs !== false && firstRun) { console.log(`${atob("Lyoh")} ${decodeURIComponent("%F0%9F%8C%BC")} ${atob("ZGFpc3lVSQ==")} ${packageVersion} ${atob("Ki8=")}`); firstRun = false; } const applyTheme = (themeName, flags) => { const theme = themesObject[themeName]; if (theme) { let selector = `${root}:has(input.theme-controller[value=${themeName}]:checked),[data-theme=${themeName}]`; if (flags.includes("--default")) { selector = `:where(${root}),${selector}`; } addBase({ [selector]: theme }); if (flags.includes("--prefersdark")) { addBase({ "@media (prefers-color-scheme: dark)": { [root]: theme } }); } } }; if (themes === "all") { if (themesObject["light"]) { applyTheme("light", ["--default"]); } if (themesObject["dark"]) { addBase({ "@media (prefers-color-scheme: dark)": { [root]: themesObject["dark"] } }); } themeOrder_default.forEach((themeName) => { if (themesObject[themeName]) { applyTheme(themeName, []); } }); } else if (themes) { const themeArray = Array.isArray(themes) ? themes : [themes]; if (themeArray.length === 1 && themeArray[0].includes("--default")) { const [themeName, ...flags] = themeArray[0].split(" "); applyTheme(themeName, flags); return { include, exclude, prefix }; } themeArray.forEach((themeOption) => { const [themeName, ...flags] = themeOption.split(" "); if (flags.includes("--default")) { applyTheme(themeName, ["--default"]); } }); themeArray.forEach((themeOption) => { const [themeName, ...flags] = themeOption.split(" "); if (flags.includes("--prefersdark")) { addBase({ "@media (prefers-color-scheme: dark)": { [root]: themesObject[themeName] } }); } }); themeArray.forEach((themeOption) => { const [themeName] = themeOption.split(" "); applyTheme(themeName, []); }); } return { include, exclude, prefix }; }; })(); // packages/daisyui/functions/plugin.js var plugin = { withOptions: (pluginFunction, configFunction = () => ({})) => { const optionsFunction = (options) => { const handler = pluginFunction(options); const config = configFunction(options); return { handler, config }; }; optionsFunction.__isOptionsFunction = true; return optionsFunction; } }; // packages/daisyui/functions/variables.js var variables_default = { colors: { "base-100": "var(--color-base-100)", "base-200": "var(--color-base-200)", "base-300": "var(--color-base-300)", "base-content": "var(--color-base-content)", primary: "var(--color-primary)", "primary-content": "var(--color-primary-content)", secondary: "var(--color-secondary)", "secondary-content": "var(--color-secondary-content)", accent: "var(--color-accent)", "accent-content": "var(--color-accent-content)", neutral: "var(--color-neutral)", "neutral-content": "var(--color-neutral-content)", info: "var(--color-info)", "info-content": "var(--color-info-content)", success: "var(--color-success)", "success-content": "var(--color-success-content)", warning: "var(--color-warning)", "warning-content": "var(--color-warning-content)", error: "var(--color-error)", "error-content": "var(--color-error-content)" }, borderRadius: { selector: "var(--radius-selector)", field: "var(--radius-field)", box: "var(--radius-box)" } }; // packages/daisyui/theme/object.js var object_default = { cyberpunk: { "color-scheme": "light", "--color-base-100": "oklch(94.51% 0.179 104.32)", "--color-base-200": "oklch(91.51% 0.179 104.32)", "--color-base-300": "oklch(85.51% 0.179 104.32)", "--color-base-content": "oklch(0% 0 0)", "--color-primary": "oklch(74.22% 0.209 6.35)", "--color-primary-content": "oklch(14.844% 0.041 6.35)", "--color-secondary": "oklch(83.33% 0.184 204.72)", "--color-secondary-content": "oklch(16.666% 0.036 204.72)", "--color-accent": "oklch(71.86% 0.217 310.43)", "--color-accent-content": "oklch(14.372% 0.043 310.43)", "--color-neutral": "oklch(23.04% 0.065 269.31)", "--color-neutral-content": "oklch(94.51% 0.179 104.32)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "0rem", "--radius-field": "0rem", "--radius-box": "0rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, acid: { "color-scheme": "light", "--color-base-100": "oklch(98% 0 0)", "--color-base-200": "oklch(95% 0 0)", "--color-base-300": "oklch(91% 0 0)", "--color-base-content": "oklch(0% 0 0)", "--color-primary": "oklch(71.9% 0.357 330.759)", "--color-primary-content": "oklch(14.38% 0.071 330.759)", "--color-secondary": "oklch(73.37% 0.224 48.25)", "--color-secondary-content": "oklch(14.674% 0.044 48.25)", "--color-accent": "oklch(92.78% 0.264 122.962)", "--color-accent-content": "oklch(18.556% 0.052 122.962)", "--color-neutral": "oklch(21.31% 0.128 278.68)", "--color-neutral-content": "oklch(84.262% 0.025 278.68)", "--color-info": "oklch(60.72% 0.227 252.05)", "--color-info-content": "oklch(12.144% 0.045 252.05)", "--color-success": "oklch(85.72% 0.266 158.53)", "--color-success-content": "oklch(17.144% 0.053 158.53)", "--color-warning": "oklch(91.01% 0.212 100.5)", "--color-warning-content": "oklch(18.202% 0.042 100.5)", "--color-error": "oklch(64.84% 0.293 29.349)", "--color-error-content": "oklch(12.968% 0.058 29.349)", "--radius-selector": "1rem", "--radius-field": "1rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, black: { "color-scheme": "dark", "--color-base-100": "oklch(0% 0 0)", "--color-base-200": "oklch(19% 0 0)", "--color-base-300": "oklch(22% 0 0)", "--color-base-content": "oklch(87.609% 0 0)", "--color-primary": "oklch(35% 0 0)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(35% 0 0)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(35% 0 0)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(35% 0 0)", "--color-neutral-content": "oklch(100% 0 0)", "--color-info": "oklch(45.201% 0.313 264.052)", "--color-info-content": "oklch(89.04% 0.062 264.052)", "--color-success": "oklch(51.975% 0.176 142.495)", "--color-success-content": "oklch(90.395% 0.035 142.495)", "--color-warning": "oklch(96.798% 0.211 109.769)", "--color-warning-content": "oklch(19.359% 0.042 109.769)", "--color-error": "oklch(62.795% 0.257 29.233)", "--color-error-content": "oklch(12.559% 0.051 29.233)", "--radius-selector": "0rem", "--radius-field": "0rem", "--radius-box": "0rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, dark: { "color-scheme": "dark", "--color-base-100": "oklch(25.33% 0.016 252.42)", "--color-base-200": "oklch(23.26% 0.014 253.1)", "--color-base-300": "oklch(21.15% 0.012 254.09)", "--color-base-content": "oklch(97.807% 0.029 256.847)", "--color-primary": "oklch(58% 0.233 277.117)", "--color-primary-content": "oklch(96% 0.018 272.314)", "--color-secondary": "oklch(65% 0.241 354.308)", "--color-secondary-content": "oklch(94% 0.028 342.258)", "--color-accent": "oklch(77% 0.152 181.912)", "--color-accent-content": "oklch(38% 0.063 188.416)", "--color-neutral": "oklch(14% 0.005 285.823)", "--color-neutral-content": "oklch(92% 0.004 286.32)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(76% 0.177 163.223)", "--color-success-content": "oklch(37% 0.077 168.94)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(71% 0.194 13.428)", "--color-error-content": "oklch(27% 0.105 12.094)", "--radius-selector": "0.5rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, light: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(98% 0 0)", "--color-base-300": "oklch(95% 0 0)", "--color-base-content": "oklch(21% 0.006 285.885)", "--color-primary": "oklch(45% 0.24 277.023)", "--color-primary-content": "oklch(93% 0.034 272.788)", "--color-secondary": "oklch(65% 0.241 354.308)", "--color-secondary-content": "oklch(94% 0.028 342.258)", "--color-accent": "oklch(77% 0.152 181.912)", "--color-accent-content": "oklch(38% 0.063 188.416)", "--color-neutral": "oklch(14% 0.005 285.823)", "--color-neutral-content": "oklch(92% 0.004 286.32)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(76% 0.177 163.223)", "--color-success-content": "oklch(37% 0.077 168.94)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(71% 0.194 13.428)", "--color-error-content": "oklch(27% 0.105 12.094)", "--radius-selector": "0.5rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, luxury: { "color-scheme": "dark", "--color-base-100": "oklch(14.076% 0.004 285.822)", "--color-base-200": "oklch(20.219% 0.004 308.229)", "--color-base-300": "oklch(23.219% 0.004 308.229)", "--color-base-content": "oklch(75.687% 0.123 76.89)", "--color-primary": "oklch(100% 0 0)", "--color-primary-content": "oklch(20% 0 0)", "--color-secondary": "oklch(27.581% 0.064 261.069)", "--color-secondary-content": "oklch(85.516% 0.012 261.069)", "--color-accent": "oklch(36.674% 0.051 338.825)", "--color-accent-content": "oklch(87.334% 0.01 338.825)", "--color-neutral": "oklch(24.27% 0.057 59.825)", "--color-neutral-content": "oklch(93.203% 0.089 90.861)", "--color-info": "oklch(79.061% 0.121 237.133)", "--color-info-content": "oklch(15.812% 0.024 237.133)", "--color-success": "oklch(78.119% 0.192 132.154)", "--color-success-content": "oklch(15.623% 0.038 132.154)", "--color-warning": "oklch(86.127% 0.136 102.891)", "--color-warning-content": "oklch(17.225% 0.027 102.891)", "--color-error": "oklch(71.753% 0.176 22.568)", "--color-error-content": "oklch(14.35% 0.035 22.568)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, dracula: { "color-scheme": "dark", "--color-base-100": "oklch(28.822% 0.022 277.508)", "--color-base-200": "oklch(26.805% 0.02 277.508)", "--color-base-300": "oklch(24.787% 0.019 277.508)", "--color-base-content": "oklch(97.747% 0.007 106.545)", "--color-primary": "oklch(75.461% 0.183 346.812)", "--color-primary-content": "oklch(15.092% 0.036 346.812)", "--color-secondary": "oklch(74.202% 0.148 301.883)", "--color-secondary-content": "oklch(14.84% 0.029 301.883)", "--color-accent": "oklch(83.392% 0.124 66.558)", "--color-accent-content": "oklch(16.678% 0.024 66.558)", "--color-neutral": "oklch(39.445% 0.032 275.524)", "--color-neutral-content": "oklch(87.889% 0.006 275.524)", "--color-info": "oklch(88.263% 0.093 212.846)", "--color-info-content": "oklch(17.652% 0.018 212.846)", "--color-success": "oklch(87.099% 0.219 148.024)", "--color-success-content": "oklch(17.419% 0.043 148.024)", "--color-warning": "oklch(95.533% 0.134 112.757)", "--color-warning-content": "oklch(19.106% 0.026 112.757)", "--color-error": "oklch(68.22% 0.206 24.43)", "--color-error-content": "oklch(13.644% 0.041 24.43)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, retro: { "color-scheme": "light", "--color-base-100": "oklch(91.637% 0.034 90.515)", "--color-base-200": "oklch(88.272% 0.049 91.774)", "--color-base-300": "oklch(84.133% 0.065 90.856)", "--color-base-content": "oklch(41% 0.112 45.904)", "--color-primary": "oklch(80% 0.114 19.571)", "--color-primary-content": "oklch(39% 0.141 25.723)", "--color-secondary": "oklch(92% 0.084 155.995)", "--color-secondary-content": "oklch(44% 0.119 151.328)", "--color-accent": "oklch(68% 0.162 75.834)", "--color-accent-content": "oklch(41% 0.112 45.904)", "--color-neutral": "oklch(44% 0.011 73.639)", "--color-neutral-content": "oklch(86% 0.005 56.366)", "--color-info": "oklch(58% 0.158 241.966)", "--color-info-content": "oklch(96% 0.059 95.617)", "--color-success": "oklch(51% 0.096 186.391)", "--color-success-content": "oklch(96% 0.059 95.617)", "--color-warning": "oklch(64% 0.222 41.116)", "--color-warning-content": "oklch(96% 0.059 95.617)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(40% 0.123 38.172)", "--radius-selector": "0.25rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, lofi: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97% 0 0)", "--color-base-300": "oklch(94% 0 0)", "--color-base-content": "oklch(0% 0 0)", "--color-primary": "oklch(15.906% 0 0)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(21.455% 0.001 17.278)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(26.861% 0 0)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(0% 0 0)", "--color-neutral-content": "oklch(100% 0 0)", "--color-info": "oklch(79.54% 0.103 205.9)", "--color-info-content": "oklch(15.908% 0.02 205.9)", "--color-success": "oklch(90.13% 0.153 164.14)", "--color-success-content": "oklch(18.026% 0.03 164.14)", "--color-warning": "oklch(88.37% 0.135 79.94)", "--color-warning-content": "oklch(17.674% 0.027 79.94)", "--color-error": "oklch(78.66% 0.15 28.47)", "--color-error-content": "oklch(15.732% 0.03 28.47)", "--radius-selector": "2rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, valentine: { "color-scheme": "light", "--color-base-100": "oklch(97% 0.014 343.198)", "--color-base-200": "oklch(94% 0.028 342.258)", "--color-base-300": "oklch(89% 0.061 343.231)", "--color-base-content": "oklch(52% 0.223 3.958)", "--color-primary": "oklch(65% 0.241 354.308)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(62% 0.265 303.9)", "--color-secondary-content": "oklch(97% 0.014 308.299)", "--color-accent": "oklch(82% 0.111 230.318)", "--color-accent-content": "oklch(39% 0.09 240.876)", "--color-neutral": "oklch(40% 0.153 2.432)", "--color-neutral-content": "oklch(89% 0.061 343.231)", "--color-info": "oklch(86% 0.127 207.078)", "--color-info-content": "oklch(44% 0.11 240.79)", "--color-success": "oklch(84% 0.143 164.978)", "--color-success-content": "oklch(43% 0.095 166.913)", "--color-warning": "oklch(75% 0.183 55.934)", "--color-warning-content": "oklch(26% 0.079 36.259)", "--color-error": "oklch(63% 0.237 25.331)", "--color-error-content": "oklch(97% 0.013 17.38)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, nord: { "color-scheme": "light", "--color-base-100": "oklch(95.127% 0.007 260.731)", "--color-base-200": "oklch(93.299% 0.01 261.788)", "--color-base-300": "oklch(89.925% 0.016 262.749)", "--color-base-content": "oklch(32.437% 0.022 264.182)", "--color-primary": "oklch(59.435% 0.077 254.027)", "--color-primary-content": "oklch(11.887% 0.015 254.027)", "--color-secondary": "oklch(69.651% 0.059 248.687)", "--color-secondary-content": "oklch(13.93% 0.011 248.687)", "--color-accent": "oklch(77.464% 0.062 217.469)", "--color-accent-content": "oklch(15.492% 0.012 217.469)", "--color-neutral": "oklch(45.229% 0.035 264.131)", "--color-neutral-content": "oklch(89.925% 0.016 262.749)", "--color-info": "oklch(69.207% 0.062 332.664)", "--color-info-content": "oklch(13.841% 0.012 332.664)", "--color-success": "oklch(76.827% 0.074 131.063)", "--color-success-content": "oklch(15.365% 0.014 131.063)", "--color-warning": "oklch(85.486% 0.089 84.093)", "--color-warning-content": "oklch(17.097% 0.017 84.093)", "--color-error": "oklch(60.61% 0.12 15.341)", "--color-error-content": "oklch(12.122% 0.024 15.341)", "--radius-selector": "1rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, lemonade: { "color-scheme": "light", "--color-base-100": "oklch(98.71% 0.02 123.72)", "--color-base-200": "oklch(91.8% 0.018 123.72)", "--color-base-300": "oklch(84.89% 0.017 123.72)", "--color-base-content": "oklch(19.742% 0.004 123.72)", "--color-primary": "oklch(58.92% 0.199 134.6)", "--color-primary-content": "oklch(11.784% 0.039 134.6)", "--color-secondary": "oklch(77.75% 0.196 111.09)", "--color-secondary-content": "oklch(15.55% 0.039 111.09)", "--color-accent": "oklch(85.39% 0.201 100.73)", "--color-accent-content": "oklch(17.078% 0.04 100.73)", "--color-neutral": "oklch(30.98% 0.075 108.6)", "--color-neutral-content": "oklch(86.196% 0.015 108.6)", "--color-info": "oklch(86.19% 0.047 224.14)", "--color-info-content": "oklch(17.238% 0.009 224.14)", "--color-success": "oklch(86.19% 0.047 157.85)", "--color-success-content": "oklch(17.238% 0.009 157.85)", "--color-warning": "oklch(86.19% 0.047 102.15)", "--color-warning-content": "oklch(17.238% 0.009 102.15)", "--color-error": "oklch(86.19% 0.047 25.85)", "--color-error-content": "oklch(17.238% 0.009 25.85)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, garden: { "color-scheme": "light", "--color-base-100": "oklch(92.951% 0.002 17.197)", "--color-base-200": "oklch(86.445% 0.002 17.197)", "--color-base-300": "oklch(79.938% 0.001 17.197)", "--color-base-content": "oklch(16.961% 0.001 17.32)", "--color-primary": "oklch(62.45% 0.278 3.836)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(48.495% 0.11 355.095)", "--color-secondary-content": "oklch(89.699% 0.022 355.095)", "--color-accent": "oklch(56.273% 0.054 154.39)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(24.155% 0.049 89.07)", "--color-neutral-content": "oklch(92.951% 0.002 17.197)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, aqua: { "color-scheme": "dark", "--color-base-100": "oklch(37% 0.146 265.522)", "--color-base-200": "oklch(28% 0.091 267.935)", "--color-base-300": "oklch(22% 0.091 267.935)", "--color-base-content": "oklch(90% 0.058 230.902)", "--color-primary": "oklch(85.661% 0.144 198.645)", "--color-primary-content": "oklch(40.124% 0.068 197.603)", "--color-secondary": "oklch(60.682% 0.108 309.782)", "--color-secondary-content": "oklch(96% 0.016 293.756)", "--color-accent": "oklch(93.426% 0.102 94.555)", "--color-accent-content": "oklch(18.685% 0.02 94.555)", "--color-neutral": "oklch(27% 0.146 265.522)", "--color-neutral-content": "oklch(80% 0.146 265.522)", "--color-info": "oklch(54.615% 0.215 262.88)", "--color-info-content": "oklch(90.923% 0.043 262.88)", "--color-success": "oklch(62.705% 0.169 149.213)", "--color-success-content": "oklch(12.541% 0.033 149.213)", "--color-warning": "oklch(66.584% 0.157 58.318)", "--color-warning-content": "oklch(27% 0.077 45.635)", "--color-error": "oklch(73.95% 0.19 27.33)", "--color-error-content": "oklch(14.79% 0.038 27.33)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, corporate: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(93% 0 0)", "--color-base-300": "oklch(86% 0 0)", "--color-base-content": "oklch(22.389% 0.031 278.072)", "--color-primary": "oklch(58% 0.158 241.966)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(55% 0.046 257.417)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(60% 0.118 184.704)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(0% 0 0)", "--color-neutral-content": "oklch(100% 0 0)", "--color-info": "oklch(60% 0.126 221.723)", "--color-info-content": "oklch(100% 0 0)", "--color-success": "oklch(62% 0.194 149.214)", "--color-success-content": "oklch(100% 0 0)", "--color-warning": "oklch(85% 0.199 91.936)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "0.25rem", "--radius-field": "0.25rem", "--radius-box": "0.25rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, pastel: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(98.462% 0.001 247.838)", "--color-base-300": "oklch(92.462% 0.001 247.838)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(90% 0.063 306.703)", "--color-primary-content": "oklch(49% 0.265 301.924)", "--color-secondary": "oklch(89% 0.058 10.001)", "--color-secondary-content": "oklch(51% 0.222 16.935)", "--color-accent": "oklch(90% 0.093 164.15)", "--color-accent-content": "oklch(50% 0.118 165.612)", "--color-neutral": "oklch(55% 0.046 257.417)", "--color-neutral-content": "oklch(92% 0.013 255.508)", "--color-info": "oklch(86% 0.127 207.078)", "--color-info-content": "oklch(52% 0.105 223.128)", "--color-success": "oklch(87% 0.15 154.449)", "--color-success-content": "oklch(52% 0.154 150.069)", "--color-warning": "oklch(83% 0.128 66.29)", "--color-warning-content": "oklch(55% 0.195 38.402)", "--color-error": "oklch(80% 0.114 19.571)", "--color-error-content": "oklch(50% 0.213 27.518)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "0", "--noise": "0" }, bumblebee: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97% 0 0)", "--color-base-300": "oklch(92% 0 0)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(85% 0.199 91.936)", "--color-primary-content": "oklch(42% 0.095 57.708)", "--color-secondary": "oklch(75% 0.183 55.934)", "--color-secondary-content": "oklch(40% 0.123 38.172)", "--color-accent": "oklch(0% 0 0)", "--color-accent-content": "oklch(100% 0 0)", "--color-neutral": "oklch(37% 0.01 67.558)", "--color-neutral-content": "oklch(92% 0.003 48.717)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(39% 0.09 240.876)", "--color-success": "oklch(76% 0.177 163.223)", "--color-success-content": "oklch(37% 0.077 168.94)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(39% 0.141 25.723)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, coffee: { "color-scheme": "dark", "--color-base-100": "oklch(24% 0.023 329.708)", "--color-base-200": "oklch(21% 0.021 329.708)", "--color-base-300": "oklch(16% 0.019 329.708)", "--color-base-content": "oklch(72.354% 0.092 79.129)", "--color-primary": "oklch(71.996% 0.123 62.756)", "--color-primary-content": "oklch(14.399% 0.024 62.756)", "--color-secondary": "oklch(34.465% 0.029 199.194)", "--color-secondary-content": "oklch(86.893% 0.005 199.194)", "--color-accent": "oklch(42.621% 0.074 224.389)", "--color-accent-content": "oklch(88.524% 0.014 224.389)", "--color-neutral": "oklch(16.51% 0.015 326.261)", "--color-neutral-content": "oklch(83.302% 0.003 326.261)", "--color-info": "oklch(79.49% 0.063 184.558)", "--color-info-content": "oklch(15.898% 0.012 184.558)", "--color-success": "oklch(74.722% 0.072 131.116)", "--color-success-content": "oklch(14.944% 0.014 131.116)", "--color-warning": "oklch(88.15% 0.14 87.722)", "--color-warning-content": "oklch(17.63% 0.028 87.722)", "--color-error": "oklch(77.318% 0.128 31.871)", "--color-error-content": "oklch(15.463% 0.025 31.871)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, silk: { "color-scheme": "light", "--color-base-100": "oklch(97% 0.0035 67.78)", "--color-base-200": "oklch(95% 0.0081 61.42)", "--color-base-300": "oklch(90% 0.0081 61.42)", "--color-base-content": "oklch(40% 0.0081 61.42)", "--color-primary": "oklch(23.27% 0.0249 284.3)", "--color-primary-content": "oklch(94.22% 0.2505 117.44)", "--color-secondary": "oklch(23.27% 0.0249 284.3)", "--color-secondary-content": "oklch(73.92% 0.2135 50.94)", "--color-accent": "oklch(23.27% 0.0249 284.3)", "--color-accent-content": "oklch(88.92% 0.2061 189.9)", "--color-neutral": "oklch(20% 0 0)", "--color-neutral-content": "oklch(80% 0.0081 61.42)", "--color-info": "oklch(80.39% 0.1148 241.68)", "--color-info-content": "oklch(30.39% 0.1148 241.68)", "--color-success": "oklch(83.92% 0.0901 136.87)", "--color-success-content": "oklch(23.92% 0.0901 136.87)", "--color-warning": "oklch(83.92% 0.1085 80)", "--color-warning-content": "oklch(43.92% 0.1085 80)", "--color-error": "oklch(75.1% 0.1814 22.37)", "--color-error-content": "oklch(35.1% 0.1814 22.37)", "--radius-selector": "2rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "1", "--noise": "0" }, sunset: { "color-scheme": "dark", "--color-base-100": "oklch(22% 0.019 237.69)", "--color-base-200": "oklch(20% 0.019 237.69)", "--color-base-300": "oklch(18% 0.019 237.69)", "--color-base-content": "oklch(77.383% 0.043 245.096)", "--color-primary": "oklch(74.703% 0.158 39.947)", "--color-primary-content": "oklch(14.94% 0.031 39.947)", "--color-secondary": "oklch(72.537% 0.177 2.72)", "--color-secondary-content": "oklch(14.507% 0.035 2.72)", "--color-accent": "oklch(71.294% 0.166 299.844)", "--color-accent-content": "oklch(14.258% 0.033 299.844)", "--color-neutral": "oklch(26% 0.019 237.69)", "--color-neutral-content": "oklch(70% 0.019 237.69)", "--color-info": "oklch(85.559% 0.085 206.015)", "--color-info-content": "oklch(17.111% 0.017 206.015)", "--color-success": "oklch(85.56% 0.085 144.778)", "--color-success-content": "oklch(17.112% 0.017 144.778)", "--color-warning": "oklch(85.569% 0.084 74.427)", "--color-warning-content": "oklch(17.113% 0.016 74.427)", "--color-error": "oklch(85.511% 0.078 16.886)", "--color-error-content": "oklch(17.102% 0.015 16.886)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, synthwave: { "color-scheme": "dark", "--color-base-100": "oklch(15% 0.09 281.288)", "--color-base-200": "oklch(20% 0.09 281.288)", "--color-base-300": "oklch(25% 0.09 281.288)", "--color-base-content": "oklch(78% 0.115 274.713)", "--color-primary": "oklch(71% 0.202 349.761)", "--color-primary-content": "oklch(28% 0.109 3.907)", "--color-secondary": "oklch(82% 0.111 230.318)", "--color-secondary-content": "oklch(29% 0.066 243.157)", "--color-accent": "oklch(75% 0.183 55.934)", "--color-accent-content": "oklch(26% 0.079 36.259)", "--color-neutral": "oklch(45% 0.24 277.023)", "--color-neutral-content": "oklch(87% 0.065 274.039)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(77% 0.152 181.912)", "--color-success-content": "oklch(27% 0.046 192.524)", "--color-warning": "oklch(90% 0.182 98.111)", "--color-warning-content": "oklch(42% 0.095 57.708)", "--color-error": "oklch(73.7% 0.121 32.639)", "--color-error-content": "oklch(23.501% 0.096 290.329)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, dim: { "color-scheme": "dark", "--color-base-100": "oklch(30.857% 0.023 264.149)", "--color-base-200": "oklch(28.036% 0.019 264.182)", "--color-base-300": "oklch(26.346% 0.018 262.177)", "--color-base-content": "oklch(82.901% 0.031 222.959)", "--color-primary": "oklch(86.133% 0.141 139.549)", "--color-primary-content": "oklch(17.226% 0.028 139.549)", "--color-secondary": "oklch(73.375% 0.165 35.353)", "--color-secondary-content": "oklch(14.675% 0.033 35.353)", "--color-accent": "oklch(74.229% 0.133 311.379)", "--color-accent-content": "oklch(14.845% 0.026 311.379)", "--color-neutral": "oklch(24.731% 0.02 264.094)", "--color-neutral-content": "oklch(82.901% 0.031 222.959)", "--color-info": "oklch(86.078% 0.142 206.182)", "--color-info-content": "oklch(17.215% 0.028 206.182)", "--color-success": "oklch(86.171% 0.142 166.534)", "--color-success-content": "oklch(17.234% 0.028 166.534)", "--color-warning": "oklch(86.163% 0.142 94.818)", "--color-warning-content": "oklch(17.232% 0.028 94.818)", "--color-error": "oklch(82.418% 0.099 33.756)", "--color-error-content": "oklch(16.483% 0.019 33.756)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, abyss: { "color-scheme": "dark", "--color-base-100": "oklch(20% 0.08 209)", "--color-base-200": "oklch(15% 0.08 209)", "--color-base-300": "oklch(10% 0.08 209)", "--color-base-content": "oklch(90% 0.076 70.697)", "--color-primary": "oklch(92% 0.2653 125)", "--color-primary-content": "oklch(50% 0.2653 125)", "--color-secondary": "oklch(83.27% 0.0764 298.3)", "--color-secondary-content": "oklch(43.27% 0.0764 298.3)", "--color-accent": "oklch(43% 0 0)", "--color-accent-content": "oklch(98% 0 0)", "--color-neutral": "oklch(30% 0.08 209)", "--color-neutral-content": "oklch(90% 0.076 70.697)", "--color-info": "oklch(74% 0.16 232.661)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(79% 0.209 151.711)", "--color-success-content": "oklch(26% 0.065 152.934)", "--color-warning": "oklch(84.8% 0.1962 84.62)", "--color-warning-content": "oklch(44.8% 0.1962 84.62)", "--color-error": "oklch(65% 0.1985 24.22)", "--color-error-content": "oklch(27% 0.1985 24.22)", "--radius-selector": "2rem", "--radius-field": "0.25rem", "--radius-box": "0.5rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, forest: { "color-scheme": "dark", "--color-base-100": "oklch(20.84% 0.008 17.911)", "--color-base-200": "oklch(18.522% 0.007 17.911)", "--color-base-300": "oklch(16.203% 0.007 17.911)", "--color-base-content": "oklch(83.768% 0.001 17.911)", "--color-primary": "oklch(68.628% 0.185 148.958)", "--color-primary-content": "oklch(0% 0 0)", "--color-secondary": "oklch(69.776% 0.135 168.327)", "--color-secondary-content": "oklch(13.955% 0.027 168.327)", "--color-accent": "oklch(70.628% 0.119 185.713)", "--color-accent-content": "oklch(14.125% 0.023 185.713)", "--color-neutral": "oklch(30.698% 0.039 171.364)", "--color-neutral-content": "oklch(86.139% 0.007 171.364)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, night: { "color-scheme": "dark", "--color-base-100": "oklch(20.768% 0.039 265.754)", "--color-base-200": "oklch(19.314% 0.037 265.754)", "--color-base-300": "oklch(17.86% 0.034 265.754)", "--color-base-content": "oklch(84.153% 0.007 265.754)", "--color-primary": "oklch(75.351% 0.138 232.661)", "--color-primary-content": "oklch(15.07% 0.027 232.661)", "--color-secondary": "oklch(68.011% 0.158 276.934)", "--color-secondary-content": "oklch(13.602% 0.031 276.934)", "--color-accent": "oklch(72.36% 0.176 350.048)", "--color-accent-content": "oklch(14.472% 0.035 350.048)", "--color-neutral": "oklch(27.949% 0.036 260.03)", "--color-neutral-content": "oklch(85.589% 0.007 260.03)", "--color-info": "oklch(68.455% 0.148 237.251)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(78.452% 0.132 181.911)", "--color-success-content": "oklch(15.69% 0.026 181.911)", "--color-warning": "oklch(83.242% 0.139 82.95)", "--color-warning-content": "oklch(16.648% 0.027 82.95)", "--color-error": "oklch(71.785% 0.17 13.118)", "--color-error-content": "oklch(14.357% 0.034 13.118)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, caramellatte: { "color-scheme": "light", "--color-base-100": "oklch(98% 0.016 73.684)", "--color-base-200": "oklch(95% 0.038 75.164)", "--color-base-300": "oklch(90% 0.076 70.697)", "--color-base-content": "oklch(40% 0.123 38.172)", "--color-primary": "oklch(0% 0 0)", "--color-primary-content": "oklch(100% 0 0)", "--color-secondary": "oklch(22.45% 0.075 37.85)", "--color-secondary-content": "oklch(90% 0.076 70.697)", "--color-accent": "oklch(46.44% 0.111 37.85)", "--color-accent-content": "oklch(90% 0.076 70.697)", "--color-neutral": "oklch(55% 0.195 38.402)", "--color-neutral-content": "oklch(98% 0.016 73.684)", "--color-info": "oklch(42% 0.199 265.638)", "--color-info-content": "oklch(90% 0.076 70.697)", "--color-success": "oklch(43% 0.095 166.913)", "--color-success-content": "oklch(90% 0.076 70.697)", "--color-warning": "oklch(82% 0.189 84.429)", "--color-warning-content": "oklch(41% 0.112 45.904)", "--color-error": "oklch(70% 0.191 22.216)", "--color-error-content": "oklch(39% 0.141 25.723)", "--radius-selector": "2rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "1", "--noise": "1" }, autumn: { "color-scheme": "light", "--color-base-100": "oklch(95.814% 0 0)", "--color-base-200": "oklch(89.107% 0 0)", "--color-base-300": "oklch(82.4% 0 0)", "--color-base-content": "oklch(19.162% 0 0)", "--color-primary": "oklch(40.723% 0.161 17.53)", "--color-primary-content": "oklch(88.144% 0.032 17.53)", "--color-secondary": "oklch(61.676% 0.169 23.865)", "--color-secondary-content": "oklch(12.335% 0.033 23.865)", "--color-accent": "oklch(73.425% 0.094 60.729)", "--color-accent-content": "oklch(14.685% 0.018 60.729)", "--color-neutral": "oklch(54.367% 0.037 51.902)", "--color-neutral-content": "oklch(90.873% 0.007 51.902)", "--color-info": "oklch(69.224% 0.097 207.284)", "--color-info-content": "oklch(13.844% 0.019 207.284)", "--color-success": "oklch(60.995% 0.08 174.616)", "--color-success-content": "oklch(12.199% 0.016 174.616)", "--color-warning": "oklch(70.081% 0.164 56.844)", "--color-warning-content": "oklch(14.016% 0.032 56.844)", "--color-error": "oklch(53.07% 0.241 24.16)", "--color-error-content": "oklch(90.614% 0.048 24.16)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, emerald: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(93% 0 0)", "--color-base-300": "oklch(86% 0 0)", "--color-base-content": "oklch(35.519% 0.032 262.988)", "--color-primary": "oklch(76.662% 0.135 153.45)", "--color-primary-content": "oklch(33.387% 0.04 162.24)", "--color-secondary": "oklch(61.302% 0.202 261.294)", "--color-secondary-content": "oklch(100% 0 0)", "--color-accent": "oklch(72.772% 0.149 33.2)", "--color-accent-content": "oklch(0% 0 0)", "--color-neutral": "oklch(35.519% 0.032 262.988)", "--color-neutral-content": "oklch(98.462% 0.001 247.838)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, cupcake: { "color-scheme": "light", "--color-base-100": "oklch(97.788% 0.004 56.375)", "--color-base-200": "oklch(93.982% 0.007 61.449)", "--color-base-300": "oklch(91.586% 0.006 53.44)", "--color-base-content": "oklch(23.574% 0.066 313.189)", "--color-primary": "oklch(85% 0.138 181.071)", "--color-primary-content": "oklch(43% 0.078 188.216)", "--color-secondary": "oklch(89% 0.061 343.231)", "--color-secondary-content": "oklch(45% 0.187 3.815)", "--color-accent": "oklch(90% 0.076 70.697)", "--color-accent-content": "oklch(47% 0.157 37.304)", "--color-neutral": "oklch(27% 0.006 286.033)", "--color-neutral-content": "oklch(92% 0.004 286.32)", "--color-info": "oklch(68% 0.169 237.323)", "--color-info-content": "oklch(29% 0.066 243.157)", "--color-success": "oklch(69% 0.17 162.48)", "--color-success-content": "oklch(26% 0.051 172.552)", "--color-warning": "oklch(79% 0.184 86.047)", "--color-warning-content": "oklch(28% 0.066 53.813)", "--color-error": "oklch(64% 0.246 16.439)", "--color-error-content": "oklch(27% 0.105 12.094)", "--radius-selector": "1rem", "--radius-field": "2rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "2px", "--depth": "1", "--noise": "0" }, cmyk: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(95% 0 0)", "--color-base-300": "oklch(90% 0 0)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(71.772% 0.133 239.443)", "--color-primary-content": "oklch(14.354% 0.026 239.443)", "--color-secondary": "oklch(64.476% 0.202 359.339)", "--color-secondary-content": "oklch(12.895% 0.04 359.339)", "--color-accent": "oklch(94.228% 0.189 105.306)", "--color-accent-content": "oklch(18.845% 0.037 105.306)", "--color-neutral": "oklch(21.778% 0 0)", "--color-neutral-content": "oklch(84.355% 0 0)", "--color-info": "oklch(68.475% 0.094 217.284)", "--color-info-content": "oklch(13.695% 0.018 217.284)", "--color-success": "oklch(46.949% 0.162 321.406)", "--color-success-content": "oklch(89.389% 0.032 321.406)", "--color-warning": "oklch(71.236% 0.159 52.023)", "--color-warning-content": "oklch(14.247% 0.031 52.023)", "--color-error": "oklch(62.013% 0.208 28.717)", "--color-error-content": "oklch(12.402% 0.041 28.717)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, business: { "color-scheme": "dark", "--color-base-100": "oklch(24.353% 0 0)", "--color-base-200": "oklch(22.648% 0 0)", "--color-base-300": "oklch(20.944% 0 0)", "--color-base-content": "oklch(84.87% 0 0)", "--color-primary": "oklch(41.703% 0.099 251.473)", "--color-primary-content": "oklch(88.34% 0.019 251.473)", "--color-secondary": "oklch(64.092% 0.027 229.389)", "--color-secondary-content": "oklch(12.818% 0.005 229.389)", "--color-accent": "oklch(67.271% 0.167 35.791)", "--color-accent-content": "oklch(13.454% 0.033 35.791)", "--color-neutral": "oklch(27.441% 0.013 253.041)", "--color-neutral-content": "oklch(85.488% 0.002 253.041)", "--color-info": "oklch(62.616% 0.143 240.033)", "--color-info-content": "oklch(12.523% 0.028 240.033)", "--color-success": "oklch(70.226% 0.094 156.596)", "--color-success-content": "oklch(14.045% 0.018 156.596)", "--color-warning": "oklch(77.482% 0.115 81.519)", "--color-warning-content": "oklch(15.496% 0.023 81.519)", "--color-error": "oklch(51.61% 0.146 29.674)", "--color-error-content": "oklch(90.322% 0.029 29.674)", "--radius-selector": "0rem", "--radius-field": "0.25rem", "--radius-box": "0.25rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, winter: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97.466% 0.011 259.822)", "--color-base-300": "oklch(93.268% 0.016 262.751)", "--color-base-content": "oklch(41.886% 0.053 255.824)", "--color-primary": "oklch(56.86% 0.255 257.57)", "--color-primary-content": "oklch(91.372% 0.051 257.57)", "--color-secondary": "oklch(42.551% 0.161 282.339)", "--color-secondary-content": "oklch(88.51% 0.032 282.339)", "--color-accent": "oklch(59.939% 0.191 335.171)", "--color-accent-content": "oklch(11.988% 0.038 335.171)", "--color-neutral": "oklch(19.616% 0.063 257.651)", "--color-neutral-content": "oklch(83.923% 0.012 257.651)", "--color-info": "oklch(88.127% 0.085 214.515)", "--color-info-content": "oklch(17.625% 0.017 214.515)", "--color-success": "oklch(80.494% 0.077 197.823)", "--color-success-content": "oklch(16.098% 0.015 197.823)", "--color-warning": "oklch(89.172% 0.045 71.47)", "--color-warning-content": "oklch(17.834% 0.009 71.47)", "--color-error": "oklch(73.092% 0.11 20.076)", "--color-error-content": "oklch(14.618% 0.022 20.076)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" }, halloween: { "color-scheme": "dark", "--color-base-100": "oklch(21% 0.006 56.043)", "--color-base-200": "oklch(14% 0.004 49.25)", "--color-base-300": "oklch(0% 0 0)", "--color-base-content": "oklch(84.955% 0 0)", "--color-primary": "oklch(77.48% 0.204 60.62)", "--color-primary-content": "oklch(19.693% 0.004 196.779)", "--color-secondary": "oklch(45.98% 0.248 305.03)", "--color-secondary-content": "oklch(89.196% 0.049 305.03)", "--color-accent": "oklch(64.8% 0.223 136.073)", "--color-accent-content": "oklch(0% 0 0)", "--color-neutral": "oklch(24.371% 0.046 65.681)", "--color-neutral-content": "oklch(84.874% 0.009 65.681)", "--color-info": "oklch(54.615% 0.215 262.88)", "--color-info-content": "oklch(90.923% 0.043 262.88)", "--color-success": "oklch(62.705% 0.169 149.213)", "--color-success-content": "oklch(12.541% 0.033 149.213)", "--color-warning": "oklch(66.584% 0.157 58.318)", "--color-warning-content": "oklch(13.316% 0.031 58.318)", "--color-error": "oklch(65.72% 0.199 27.33)", "--color-error-content": "oklch(13.144% 0.039 27.33)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, fantasy: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(93% 0 0)", "--color-base-300": "oklch(86% 0 0)", "--color-base-content": "oklch(27.807% 0.029 256.847)", "--color-primary": "oklch(37.45% 0.189 325.02)", "--color-primary-content": "oklch(87.49% 0.037 325.02)", "--color-secondary": "oklch(53.92% 0.162 241.36)", "--color-secondary-content": "oklch(90.784% 0.032 241.36)", "--color-accent": "oklch(75.98% 0.204 56.72)", "--color-accent-content": "oklch(15.196% 0.04 56.72)", "--color-neutral": "oklch(27.807% 0.029 256.847)", "--color-neutral-content": "oklch(85.561% 0.005 256.847)", "--color-info": "oklch(72.06% 0.191 231.6)", "--color-info-content": "oklch(0% 0 0)", "--color-success": "oklch(64.8% 0.15 160)", "--color-success-content": "oklch(0% 0 0)", "--color-warning": "oklch(84.71% 0.199 83.87)", "--color-warning-content": "oklch(0% 0 0)", "--color-error": "oklch(71.76% 0.221 22.18)", "--color-error-content": "oklch(0% 0 0)", "--radius-selector": "1rem", "--radius-field": "0.5rem", "--radius-box": "1rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "1", "--noise": "0" }, wireframe: { "color-scheme": "light", "--color-base-100": "oklch(100% 0 0)", "--color-base-200": "oklch(97% 0 0)", "--color-base-300": "oklch(94% 0 0)", "--color-base-content": "oklch(20% 0 0)", "--color-primary": "oklch(87% 0 0)", "--color-primary-content": "oklch(26% 0 0)", "--color-secondary": "oklch(87% 0 0)", "--color-secondary-content": "oklch(26% 0 0)", "--color-accent": "oklch(87% 0 0)", "--color-accent-content": "oklch(26% 0 0)", "--color-neutral": "oklch(87% 0 0)", "--color-neutral-content": "oklch(26% 0 0)", "--color-info": "oklch(44% 0.11 240.79)", "--color-info-content": "oklch(90% 0.058 230.902)", "--color-success": "oklch(43% 0.095 166.913)", "--color-success-content": "oklch(90% 0.093 164.15)", "--color-warning": "oklch(47% 0.137 46.201)", "--color-warning-content": "oklch(92% 0.12 95.746)", "--color-error": "oklch(44% 0.177 26.899)", "--color-error-content": "oklch(88% 0.062 18.334)", "--radius-selector": "0rem", "--radius-field": "0.25rem", "--radius-box": "0.25rem", "--size-selector": "0.25rem", "--size-field": "0.25rem", "--border": "1px", "--depth": "0", "--noise": "0" } }; // packages/daisyui/base/rootscrolllock/object.js var object_default2 = { ':root:has( .modal-open, .modal[open], .modal:target, .modal-toggle:checked, .drawer:not([class*="drawer-open"]) > .drawer-toggle:checked )': { overflow: "hidden" } }; // packages/daisyui/functions/addPrefix.js var defaultExcludedPrefixes = ["color-", "size-", "radius-", "border", "depth", "noise"]; var shouldExcludeVariable = (variableName, excludedPrefixes) => { if (variableName.startsWith("tw")) { return true; } return excludedPrefixes.some((excludedPrefix) => variableName.startsWith(excludedPrefix)); }; var prefixVariable = (variableName, prefix, excludedPrefixes) => { if (shouldExcludeVariable(variableName, excludedPrefixes)) { return variableName; } return `${prefix}${variableName}`; }; var getPrefixedSelector = (selector, prefix) => { if (!selector.startsWith(".")) return selector; return `.${prefix}${selector.slice(1)}`; }; var getPrefixedKey = (key, prefix, excludedPrefixes) => { const prefixAmpDot = prefix ? `&.${prefix}` : ""; if (!prefix) return key; if (key.startsWith("--")) { const variableName = key.slice(2); return `--${prefixVariable(variableName, prefix, excludedPrefixes)}`; } if (key.startsWith("@") || key.startsWith("[")) { return key; } if (key.startsWith("&")) { if (key.match(/:[a-z-]+\(/)) { return key.replace(/\.([\w-]+)/g, `.${prefix}$1`); } if (key.startsWith("&.")) { return `${prefixAmpDot}${key.slice(2)}`; } return key.replace(/\.([\w-]+)/g, `.${prefix}$1`); } if (key.startsWith(":")) { return key.replace(/\.([\w-]+)/g, `.${prefix}$1`); } if (key.includes(".") && !key.includes(" ") && !key.includes(">") && !key.includes("+") && !key.includes("~")) { return key.split(".").filter(Boolean).map((part) => prefix + part).join(".").replace(/^/, "."); } if (key.includes(">") || key.includes("+") || key.includes("~")) { if (key.includes(",")) { return key.split(/\s*,\s*/).map((part) => { return part.replace(/\.([\w-]+)/g, `.${prefix}$1`); }).join(", "); } let processedKey = key.replace(/\.([\w-]+)/g, `.${prefix}$1`); if (processedKey.startsWith(">") || processedKey.startsWith("+") || processedKey.startsWith("~")) { processedKey = ` ${processedKey}`; } return processedKey; } if (key.includes(" ")) { return key.split(/\s+/).map((part) => { if (part.startsWith(".")) { return getPrefixedSelector(part, prefix); } return part; }).join(" "); } if (key.includes(":")) { const [selector, ...pseudo] = key.split(":"); if (selector.startsWith(".")) { return `${getPrefixedSelector(selector, prefix)}:${pseudo.join(":")}`; } return key.replace(/\.([\w-]+)/g, `.${prefix}$1`); } if (key.startsWith(".")) { return getPrefixedSelector(key, prefix); } return key; }; var processArrayValue = (value, prefix, excludedPrefixes) => { return value.map((item) => { if (typeof item === "string") { if (item.startsWith(".")) { return prefix ? `.${prefix}${item.slice(1)}` : item; } return processStringValue(item, prefix, excludedPrefixes); } return item; }); }; var processStringValue = (value, prefix, excludedPrefixes) => { if (prefix === 0) return value; return value.replace(/var\(--([^)]+)\)/g, (match, variableName) => { if (shouldExcludeVariable(variableName, excludedPrefixes)) { return match; } return `var(--${prefix}${variableName})`; }); }; var processValue = (value, prefix, excludedPrefixes) => { if (Array.isArray(value)) { return processArrayValue(value, prefix, excludedPrefixes); } else if (typeof value === "object" && value !== null) { return addPrefix(value, prefix, excludedPrefixes); } else if (typeof value === "string") { return processStringValue(value, prefix, excludedPrefixes); } else { return value; } }; var addPrefix = (obj, prefix, excludedPrefixes = defaultExcludedPrefixes) => { return Object.entries(obj).reduce((result, [key, value]) => { const newKey = getPrefixedKey(key, prefix, excludedPrefixes); result[newKey] = processValue(value, prefix, excludedPrefixes); return result; }, {}); }; // packages/daisyui/base/rootscrolllock/index.js var rootscrolllock_default = ({ addBase, prefix = "" }) => { const prefixedrootscrolllock = addPrefix(object_default2, prefix); addBase({ ...prefixedrootscrolllock }); }; // packages/daisyui/base/rootcolor/object.js var object_default3 = { ":root, [data-theme]": { "background-color": "var(--root-bg, var(--color-base-100))", color: "var(--color-base-content)" } }; // packages/daisyui/base/rootcolor/index.js var rootcolor_default = ({ addBase, prefix = "" }) => { const prefixedrootcolor = addPrefix(object_default3, prefix); addBase({ ...prefixedrootcolor }); }; // packages/daisyui/base/scrollbar/object.js var object_default4 = { ":root": { "scrollbar-color": "color-mix(in oklch, currentColor 35%, #0000) #0000" } }; // packages/daisyui/base/scrollbar/index.js var scrollbar_default = ({ addBase, prefix = "" }) => { const prefixedscrollbar = addPrefix(object_default4, prefix); addBase({ ...prefixedscrollbar }); }; // packages/daisyui/base/properties/object.js var object_default5 = { "@property --radialprogress": { syntax: '""', inherits: "true", "initial-value": "0%" } }; // packages/daisyui/base/properties/index.js var properties_default = ({ addBase, prefix = "" }) => { const prefixedproperties = addPrefix(object_default5, prefix); addBase({ ...prefixedproperties }); }; // packages/daisyui/base/rootscrollgutter/object.js var object_default6 = { ":where( :root:has( .modal-open, .modal[open], .modal:target, .modal-toggle:checked, .drawer:not(.drawer-open) > .drawer-toggle:checked ) )": { "scrollbar-gutter": "stable", "background-image": "linear-gradient(var(--color-base-100), var(--color-base-100))", "--root-bg": "color-mix(in srgb, var(--color-base-100), oklch(0% 0 0) 40%)" }, ":where(.modal[open], .modal-open, .modal-toggle:checked + .modal):not(.modal-start, .modal-end)": { "scrollbar-gutter": "stable" } }; // packages/daisyui/base/rootscrollgutter/index.js var rootscrollgutter_default = ({ addBase, prefix = "" }) => { const prefixedrootscrollgutter = addPrefix(object_default6, prefix); addBase({ ...prefixedrootscrollgutter }); }; // packages/daisyui/base/svg/object.js var object_default7 = { ":root": { "--fx-noise": `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='a'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='1.34' numOctaves='4' stitchTiles='stitch'%3E%3C/feTurbulence%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23a)' opacity='0.2'%3E%3C/rect%3E%3C/svg%3E")` }, ".chat": { "--mask-chat": `url("data:image/svg+xml,%3csvg width='13' height='13' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='M0 11.5004C0 13.0004 2 13.0004 2 13.0004H12H13V0.00036329L12.5 0C12.5 0 11.977 2.09572 11.8581 2.50033C11.6075 3.35237 10.9149 4.22374 9 5.50036C6 7.50036 0 10.0004 0 11.5004Z'/%3e%3c/svg%3e")` } }; // packages/daisyui/base/svg/index.js var svg_default = ({ addBase, prefix = "" }) => { const prefixedsvg = addPrefix(object_default7, prefix); addBase({ ...prefixedsvg }); }; // packages/daisyui/components/drawer/object.js var object_default8 = { ".drawer": { position: "relative", display: "grid", width: "100%", "grid-auto-columns": "max-content auto" }, ".drawer-content": { "grid-column-start": "2", "grid-row-start": "1", "min-width": "calc(0.25rem * 0)" }, ".drawer-side": { "pointer-events": "none", visibility: "hidden", position: "fixed", "inset-inline-start": "calc(0.25rem * 0)", top: "calc(0.25rem * 0)", "z-index": 1, "grid-column-start": "1", "grid-row-start": "1", display: "grid", width: "100%", "grid-template-columns": "repeat(1, minmax(0, 1fr))", "grid-template-rows": "repeat(1, minmax(0, 1fr))", "align-items": "flex-start", "justify-items": "start", "overflow-x": "hidden", "overflow-y": "hidden", "overscroll-behavior": "contain", opacity: "0%", transition: "opacity 0.2s ease-out 0.1s allow-discrete, visibility 0.3s ease-out 0.1s allow-discrete", height: ["100vh", "100dvh"], "> .drawer-overlay": { position: "sticky", top: "calc(0.25rem * 0)", cursor: "pointer", "place-self": "stretch", "background-color": "oklch(0% 0 0 / 40%)" }, "> *": { "grid-column-start": "1", "grid-row-start": "1" }, "> *:not(.drawer-overlay)": { "will-change": "transform", transition: "translate 0.3s ease-out", translate: "-100%", '[dir="rtl"] &': { translate: "100%" } } }, ".drawer-toggle": { position: "fixed", height: "calc(0.25rem * 0)", width: "calc(0.25rem * 0)", appearance: "none", opacity: "0%", "&:checked": { "& ~ .drawer-side": { "pointer-events": "auto", visibility: "visible", "overflow-y": "auto", opacity: "100%", "& > *:not(.drawer-overlay)": { translate: "0%" } } }, "&:focus-visible ~ .drawer-content label.drawer-button": { outline: "2px solid", "outline-offset": "2px" } }, ".drawer-end": { "grid-auto-columns": "auto max-content", "> .drawer-toggle": { "& ~ .drawer-content": { "grid-column-start": "1" }, "& ~ .drawer-side": { "grid-column-start": "2", "justify-items": "end" }, "& ~ .drawer-side > *:not(.drawer-overlay)": { translate: "100%", '[dir="rtl"] &': { translate: "-100%" } }, "&:checked ~ .drawer-side > *:not(.drawer-overlay)": { translate: "0%" } } }, ".drawer-open": { "> .drawer-side": { "overflow-y": "auto" }, "> .drawer-toggle": { display: "none", "& ~ .drawer-side": { "pointer-events": "auto", visibility: "visible", position: "sticky", display: "block", width: "auto", "overscroll-behavior": "auto", opacity: "100%", "& > .drawer-overlay": { cursor: "default", "background-color": "transparent" }, "& > *:not(.drawer-overlay)": { translate: "0%", '[dir="rtl"] &': { translate: "0%" } } }, "&:checked ~ .drawer-side": { "pointer-events": "auto", visibility: "visible" } } } }; // packages/daisyui/components/drawer/index.js var drawer_default = ({ addComponents, prefix = "" }) => { const prefixeddrawer = addPrefix(object_default8, prefix); addComponents({ ...prefixeddrawer }); }; // packages/daisyui/components/link/object.js var object_default9 = { ".link": { cursor: "pointer", "text-decoration-line": "underline", "&:focus": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } }, "&:focus-visible": { outline: "2px solid currentColor", "outline-offset": "2px" } }, ".link-hover": { "text-decoration-line": "none", "&:hover": { "@media (hover: hover)": { "text-decoration-line": "underline" } } }, ".link-primary": { color: "var(--color-primary)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-primary) 80%, #000)" } } }, ".link-secondary": { color: "var(--color-secondary)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-secondary) 80%, #000)" } } }, ".link-accent": { color: "var(--color-accent)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-accent) 80%, #000)" } } }, ".link-neutral": { color: "var(--color-neutral)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-neutral) 80%, #000)" } } }, ".link-success": { color: "var(--color-success)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-success) 80%, #000)" } } }, ".link-info": { color: "var(--color-info)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-info) 80%, #000)" } } }, ".link-warning": { color: "var(--color-warning)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-warning) 80%, #000)" } } }, ".link-error": { color: "var(--color-error)", "@media (hover: hover)": { "&:hover": { color: "color-mix(in oklab, var(--color-error) 80%, #000)" } } } }; // packages/daisyui/components/link/index.js var link_default = ({ addComponents, prefix = "" }) => { const prefixedlink = addPrefix(object_default9, prefix); addComponents({ ...prefixedlink }); }; // packages/daisyui/components/stat/object.js var object_default10 = { ".stats": { position: "relative", display: "inline-grid", "grid-auto-flow": "column", "overflow-x": "auto", "border-radius": "var(--radius-box)" }, ".stat": { display: "inline-grid", width: "100%", "column-gap": "calc(0.25rem * 4)", "padding-inline": "calc(0.25rem * 6)", "padding-block": "calc(0.25rem * 4)", "grid-template-columns": "repeat(1, 1fr)", "&:not(:last-child)": { "border-inline-end": "var(--border) dashed color-mix(in oklab, currentColor 10%, #0000)", "border-block-end": "none" } }, ".stat-figure": { "grid-column-start": "2", "grid-row": "span 3 / span 3", "grid-row-start": "1", "place-self": "center", "justify-self": "flex-end" }, ".stat-title": { "grid-column-start": "1", "white-space": "nowrap", color: "color-mix(in oklab, var(--color-base-content) 60%, transparent)", "font-size": "0.75rem" }, ".stat-value": { "grid-column-start": "1", "white-space": "nowrap", "font-size": "2rem", "font-weight": 800 }, ".stat-desc": { "grid-column-start": "1", "white-space": "nowrap", color: "color-mix(in oklab, var(--color-base-content) 60%, transparent)", "font-size": "0.75rem" }, ".stat-actions": { "grid-column-start": "1", "white-space": "nowrap" }, ".stats-horizontal": { "grid-auto-flow": "column", "overflow-x": "auto", ".stat:not(:last-child)": { "border-inline-end": "var(--border) dashed color-mix(in oklab, currentColor 10%, #0000)", "border-block-end": "none" } }, ".stats-vertical": { "grid-auto-flow": "row", "overflow-y": "auto", ".stat:not(:last-child)": { "border-inline-end": "none", "border-block-end": "var(--border) dashed color-mix(in oklab, currentColor 10%, #0000)" } } }; // packages/daisyui/components/stat/index.js var stat_default = ({ addComponents, prefix = "" }) => { const prefixedstat = addPrefix(object_default10, prefix); addComponents({ ...prefixedstat }); }; // packages/daisyui/components/carousel/object.js var object_default11 = { ".carousel": { display: "inline-flex", "overflow-x": "scroll", "scroll-snap-type": "x mandatory", "scroll-behavior": "smooth", "scrollbar-width": "none", "&::-webkit-scrollbar": { display: "none" } }, ".carousel-vertical": { "flex-direction": "column", "overflow-y": "scroll", "scroll-snap-type": "y mandatory" }, ".carousel-horizontal": { "flex-direction": "row", "overflow-x": "scroll", "scroll-snap-type": "x mandatory" }, ".carousel-item": { "box-sizing": "content-box", display: "flex", flex: "none", "scroll-snap-align": "start" }, ".carousel-start": { ".carousel-item": { "scroll-snap-align": "start" } }, ".carousel-center": { ".carousel-item": { "scroll-snap-align": "center" } }, ".carousel-end": { ".carousel-item": { "scroll-snap-align": "end" } } }; // packages/daisyui/components/carousel/index.js var carousel_default = ({ addComponents, prefix = "" }) => { const prefixedcarousel = addPrefix(object_default11, prefix); addComponents({ ...prefixedcarousel }); }; // packages/daisyui/components/divider/object.js var object_default12 = { ".divider": { display: "flex", height: "calc(0.25rem * 4)", "flex-direction": "row", "align-items": "center", "align-self": "stretch", "white-space": "nowrap", margin: "var(--divider-m, 1rem 0)", "--divider-color": "color-mix(in oklab, var(--color-base-content) 10%, transparent)", "&:before, &:after": { content: '""', height: "calc(0.25rem * 0.5)", width: "100%", "flex-grow": 1, "background-color": "var(--divider-color)" }, "@media print": { "&:before, &:after": { border: "0.5px solid" } }, "&:not(:empty)": { gap: "calc(0.25rem * 4)" } }, ".divider-horizontal": { "--divider-m": "0 1rem", "&.divider": { height: "auto", width: "calc(0.25rem * 4)", "flex-direction": "column", "&:before": { height: "100%", width: "calc(0.25rem * 0.5)" }, "&:after": { height: "100%", width: "calc(0.25rem * 0.5)" } } }, ".divider-vertical": { "--divider-m": "1rem 0", "&.divider": { height: "calc(0.25rem * 4)", width: "auto", "flex-direction": "row", "&:before": { height: "calc(0.25rem * 0.5)", width: "100%" }, "&:after": { height: "calc(0.25rem * 0.5)", width: "100%" } } }, ".divider-neutral": { "&:before, &:after": { "background-color": "var(--color-neutral)" } }, ".divider-primary": { "&:before, &:after": { "background-color": "var(--color-primary)" } }, ".divider-secondary": { "&:before, &:after": { "background-color": "var(--color-secondary)" } }, ".divider-accent": { "&:before, &:after": { "background-color": "var(--color-accent)" } }, ".divider-success": { "&:before, &:after": { "background-color": "var(--color-success)" } }, ".divider-warning": { "&:before, &:after": { "background-color": "var(--color-warning)" } }, ".divider-info": { "&:before, &:after": { "background-color": "var(--color-info)" } }, ".divider-error": { "&:before, &:after": { "background-color": "var(--color-error)" } }, ".divider-start:before": { display: "none" }, ".divider-end:after": { display: "none" } }; // packages/daisyui/components/divider/index.js var divider_default = ({ addComponents, prefix = "" }) => { const prefixeddivider = addPrefix(object_default12, prefix); addComponents({ ...prefixeddivider }); }; // packages/daisyui/components/mask/object.js var object_default13 = { ".mask": { display: "inline-block", "vertical-align": "middle", "mask-size": "contain", "mask-repeat": "no-repeat", "mask-position": "center" }, ".mask-half-1": { "mask-size": "200%", "mask-position": ["left", "left"], '&:where(:dir(rtl), [dir="rtl"], [dir="rtl"] *)': { "mask-position": "right" } }, ".mask-half-2": { "mask-size": "200%", "mask-position": ["right", "right"], '&:where(:dir(rtl), [dir="rtl"], [dir="rtl"] *)': { "mask-position": "left" } }, ".mask-squircle": { "mask-image": `url("data:image/svg+xml,%3csvg width='200' height='200' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M100 0C20 0 0 20 0 100s20 100 100 100 100-20 100-100S180 0 100 0Z'/%3e%3c/svg%3e")` }, ".mask-decagon": { "mask-image": `url("data:image/svg+xml,%3csvg width='192' height='200' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m96 0 58.779 19.098 36.327 50v61.804l-36.327 50L96 200l-58.779-19.098-36.327-50V69.098l36.327-50z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-diamond": { "mask-image": `url("data:image/svg+xml,%3csvg width='200' height='200' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m100 0 100 100-100 100L0 100z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-heart": { "mask-image": `url("data:image/svg+xml,%3csvg width='200' height='185' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M100 184.606a15.384 15.384 0 0 1-8.653-2.678C53.565 156.28 37.205 138.695 28.182 127.7 8.952 104.264-.254 80.202.005 54.146.308 24.287 24.264 0 53.406 0c21.192 0 35.869 11.937 44.416 21.879a2.884 2.884 0 0 0 4.356 0C110.725 11.927 125.402 0 146.594 0c29.142 0 53.098 24.287 53.4 54.151.26 26.061-8.956 50.122-28.176 73.554-9.023 10.994-25.383 28.58-63.165 54.228a15.384 15.384 0 0 1-8.653 2.673Z' fill='black' fill-rule='nonzero'/%3e%3c/svg%3e")` }, ".mask-hexagon": { "mask-image": `url("data:image/svg+xml,%3csvg width='182' height='201' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M.3 65.486c0-9.196 6.687-20.063 14.211-25.078l61.86-35.946c8.36-5.016 20.899-5.016 29.258 0l61.86 35.946c8.36 5.015 14.211 15.882 14.211 25.078v71.055c0 9.196-6.687 20.063-14.211 25.079l-61.86 35.945c-8.36 4.18-20.899 4.18-29.258 0L14.51 161.62C6.151 157.44.3 145.737.3 136.54V65.486Z' fill='black' fill-rule='nonzero'/%3e%3c/svg%3e")` }, ".mask-hexagon-2": { "mask-image": `url("data:image/svg+xml,%3csvg width='200' height='182' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M64.786 181.4c-9.196 0-20.063-6.687-25.079-14.21L3.762 105.33c-5.016-8.36-5.016-20.9 0-29.259l35.945-61.86C44.723 5.851 55.59 0 64.786 0h71.055c9.196 0 20.063 6.688 25.079 14.211l35.945 61.86c4.18 8.36 4.18 20.899 0 29.258l-35.945 61.86c-4.18 8.36-15.883 14.211-25.079 14.211H64.786Z' fill='black' fill-rule='nonzero'/%3e%3c/svg%3e")` }, ".mask-circle": { "mask-image": `url("data:image/svg+xml,%3csvg width='200' height='200' xmlns='http://www.w3.org/2000/svg'%3e%3ccircle fill='black' cx='100' cy='100' r='100' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-pentagon": { "mask-image": `url("data:image/svg+xml,%3csvg width='192' height='181' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m96 0 95.106 69.098-36.327 111.804H37.22L.894 69.098z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-star": { "mask-image": `url("data:image/svg+xml,%3csvg width='192' height='180' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m96 137.263-58.779 42.024 22.163-68.389L.894 68.481l72.476-.243L96 0l22.63 68.238 72.476.243-58.49 42.417 22.163 68.389z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-star-2": { "mask-image": `url("data:image/svg+xml,%3csvg width='192' height='180' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m96 153.044-58.779 26.243 7.02-63.513L.894 68.481l63.117-13.01L96 0l31.989 55.472 63.117 13.01-43.347 47.292 7.02 63.513z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-triangle": { "mask-image": `url("data:image/svg+xml,%3csvg width='174' height='149' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m87 148.476-86.603.185L43.86 74.423 87 0l43.14 74.423 43.463 74.238z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-triangle-2": { "mask-image": `url("data:image/svg+xml,%3csvg width='174' height='150' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m87 .738 86.603-.184-43.463 74.238L87 149.214 43.86 74.792.397.554z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-triangle-3": { "mask-image": `url("data:image/svg+xml,%3csvg width='150' height='174' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='m149.369 87.107.185 86.603-74.239-43.463L.893 87.107l74.422-43.14L149.554.505z' fill-rule='evenodd'/%3e%3c/svg%3e")` }, ".mask-triangle-4": { "mask-image": `url("data:image/svg+xml,%3csvg width='150' height='174' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='M.631 87.107.446.505l74.239 43.462 74.422 43.14-74.422 43.14L.446 173.71z' fill-rule='evenodd'/%3e%3c/svg%3e")` } }; // packages/daisyui/components/mask/index.js var mask_default = ({ addComponents, prefix = "" }) => { const prefixedmask = addPrefix(object_default13, prefix); addComponents({ ...prefixedmask }); }; // packages/daisyui/components/fieldset/object.js var object_default14 = { ".fieldset": { display: "grid", gap: "calc(0.25rem * 1.5)", "padding-block": "calc(0.25rem * 1)", "font-size": "0.75rem", "grid-template-columns": "1fr", "grid-auto-rows": "max-content" }, ".fieldset-legend": { "margin-bottom": "calc(0.25rem * -1)", display: "flex", "align-items": "center", "justify-content": "space-between", gap: "calc(0.25rem * 2)", "padding-block": "calc(0.25rem * 2)", color: "var(--color-base-content)", "font-weight": 600 }, ".fieldset-label": { display: "flex", "align-items": "center", gap: "calc(0.25rem * 1.5)", color: "color-mix(in oklab, var(--color-base-content) 60%, transparent)", "&:has(input)": { cursor: "pointer" } } }; // packages/daisyui/components/fieldset/index.js var fieldset_default = ({ addComponents, prefix = "" }) => { const prefixedfieldset = addPrefix(object_default14, prefix); addComponents({ ...prefixedfieldset }); }; // packages/daisyui/components/dropdown/object.js var object_default15 = { ".dropdown": { position: "relative", display: "inline-block", "position-area": "var(--anchor-v, bottom) var(--anchor-h, span-right)", "& > *:not(summary):focus": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } }, ".dropdown-content": { position: "absolute" }, "&:not(details, .dropdown-open, .dropdown-hover:hover, :focus-within)": { ".dropdown-content": { display: "none", "transform-origin": "top", opacity: "0%", scale: "95%" } }, "&[popover], .dropdown-content": { "z-index": 999, animation: "dropdown 0.2s", "transition-property": "opacity, scale, display", "transition-behavior": "allow-discrete", "transition-duration": "0.2s", "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)" }, "@starting-style": { "&[popover], .dropdown-content": { scale: "95%", opacity: 0 } }, "&.dropdown-open, &:not(.dropdown-hover):focus, &:focus-within": { "> [tabindex]:first-child": { "pointer-events": "none" }, ".dropdown-content": { opacity: "100%" } }, "&.dropdown-hover:hover": { ".dropdown-content": { opacity: "100%", scale: "100%" } }, "&:is(details)": { summary: { "&::-webkit-details-marker": { display: "none" } } }, "&.dropdown-open, &:focus, &:focus-within": { ".dropdown-content": { scale: "100%" } }, "&:where([popover])": { background: "#0000" }, "&[popover]": { position: "fixed", color: "inherit", "@supports not (position-area: bottom)": { margin: "auto", "&.dropdown-open:not(:popover-open)": { display: "none", "transform-origin": "top", opacity: "0%", scale: "95%" }, "&::backdrop": { "background-color": "color-mix(in oklab, #000 30%, #0000)" } }, "&:not(.dropdown-open, :popover-open)": { display: "none", "transform-origin": "top", opacity: "0%", scale: "95%" } } }, ".dropdown-start": { "--anchor-h": "span-right", ":where(.dropdown-content)": { "inset-inline-end": "auto" }, "&.dropdown-left": { "--anchor-h": "left", "--anchor-v": "span-bottom", ".dropdown-content": { top: "calc(0.25rem * 0)", bottom: "auto" } }, "&.dropdown-right": { "--anchor-h": "right", "--anchor-v": "span-bottom", ".dropdown-content": { top: "calc(0.25rem * 0)", bottom: "auto" } } }, ".dropdown-center": { "--anchor-h": "center", ":where(.dropdown-content)": { "inset-inline-end": "calc(1/2 * 100%)", translate: "50% 0", '[dir="rtl"] &': { translate: "-50% 0" } }, "&.dropdown-left": { "--anchor-h": "left", "--anchor-v": "center", ".dropdown-content": { top: "auto", bottom: "calc(1/2 * 100%)", translate: "0 50%" } }, "&.dropdown-right": { "--anchor-h": "right", "--anchor-v": "center", ".dropdown-content": { top: "auto", bottom: "calc(1/2 * 100%)", translate: "0 50%" } } }, ".dropdown-end": { "--anchor-h": "span-left", ":where(.dropdown-content)": { "inset-inline-end": "calc(0.25rem * 0)", translate: "0 0" }, "&.dropdown-left": { "--anchor-h": "left", "--anchor-v": "span-top", ".dropdown-content": { top: "auto", bottom: "calc(0.25rem * 0)" } }, "&.dropdown-right": { "--anchor-h": "right", "--anchor-v": "span-top", ".dropdown-content": { top: "auto", bottom: "calc(0.25rem * 0)" } } }, ".dropdown-left": { "--anchor-h": "left", "--anchor-v": "span-bottom", ".dropdown-content": { "inset-inline-end": "100%", top: "calc(0.25rem * 0)", bottom: "auto", "transform-origin": "right" } }, ".dropdown-right": { "--anchor-h": "right", "--anchor-v": "span-bottom", ".dropdown-content": { "inset-inline-start": "100%", top: "calc(0.25rem * 0)", bottom: "auto", "transform-origin": "left" } }, ".dropdown-bottom": { "--anchor-v": "bottom", ".dropdown-content": { top: "100%", bottom: "auto", "transform-origin": "top" } }, ".dropdown-top": { "--anchor-v": "top", ".dropdown-content": { top: "auto", bottom: "100%", "transform-origin": "bottom" } }, "@keyframes dropdown": { "0%": { opacity: 0 } } }; // packages/daisyui/components/dropdown/index.js var dropdown_default = ({ addComponents, prefix = "" }) => { const prefixeddropdown = addPrefix(object_default15, prefix); addComponents({ ...prefixeddropdown }); }; // packages/daisyui/components/card/object.js var object_default16 = { ".card": { position: "relative", display: "flex", "flex-direction": "column", "border-radius": "var(--radius-box)", "outline-width": "2px", transition: "outline 0.2s ease-in-out", outline: "0 solid #0000", "outline-offset": "2px", "&:focus": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } }, "&:focus-visible": { "outline-color": "currentColor" }, ":where(figure:first-child)": { overflow: "hidden", "border-start-start-radius": "inherit", "border-start-end-radius": "inherit", "border-end-start-radius": "unset", "border-end-end-radius": "unset" }, ":where(figure:last-child)": { overflow: "hidden", "border-start-start-radius": "unset", "border-start-end-radius": "unset", "border-end-start-radius": "inherit", "border-end-end-radius": "inherit" }, "&:where(.card-border)": { border: "var(--border) solid var(--color-base-200)" }, "&:where(.card-dash)": { border: "var(--border) dashed var(--color-base-200)" }, "&.image-full": { display: "grid", "> *": { "grid-column-start": "1", "grid-row-start": "1" }, "> .card-body": { position: "relative", color: "var(--color-neutral-content)" }, ":where(figure)": { overflow: "hidden", "border-radius": "inherit" }, "> figure img": { height: "100%", "object-fit": "cover", filter: "brightness(28%)" } }, figure: { display: "flex", "align-items": "center", "justify-content": "center" }, '&:has(> input:is(input[type="checkbox"], input[type="radio"]))': { cursor: "pointer", "user-select": "none" }, "&:has(> :checked)": { outline: "2px solid currentColor" } }, ".card-title": { display: "flex", "align-items": "center", gap: "calc(0.25rem * 2)", "font-size": "var(--cardtitle-fs, 1.125rem)", "font-weight": 600 }, ".card-body": { display: "flex", flex: "auto", "flex-direction": "column", gap: "calc(0.25rem * 2)", padding: "var(--card-p, 1.5rem)", "font-size": "var(--card-fs, 0.875rem)", ":where(p)": { "flex-grow": 1 } }, ".card-actions": { display: "flex", "flex-wrap": "wrap", "align-items": "flex-start", gap: "calc(0.25rem * 2)" }, ".card-xs": { ".card-body": { "--card-p": "0.5rem", "--card-fs": "0.6875rem" }, ".card-title": { "--cardtitle-fs": "0.875rem" } }, ".card-sm": { ".card-body": { "--card-p": "1rem", "--card-fs": "0.75rem" }, ".card-title": { "--cardtitle-fs": "1rem" } }, ".card-md": { ".card-body": { "--card-p": "1.5rem", "--card-fs": "0.875rem" }, ".card-title": { "--cardtitle-fs": "1.125rem" } }, ".card-lg": { ".card-body": { "--card-p": "2rem", "--card-fs": "1rem" }, ".card-title": { "--cardtitle-fs": "1.25rem" } }, ".card-xl": { ".card-body": { "--card-p": "2.5rem", "--card-fs": "1.125rem" }, ".card-title": { "--cardtitle-fs": "1.375rem" } }, ".card-side": { "align-items": "stretch", "flex-direction": "row", ":where(figure:first-child)": { overflow: "hidden", "border-start-start-radius": "inherit", "border-start-end-radius": "unset", "border-end-start-radius": "inherit", "border-end-end-radius": "unset" }, ":where(figure:last-child)": { overflow: "hidden", "border-start-start-radius": "unset", "border-start-end-radius": "inherit", "border-end-start-radius": "unset", "border-end-end-radius": "inherit" }, "figure > *": { "max-width": "unset" }, ":where(figure > *)": { width: "100%", height: "100%", "object-fit": "cover" } } }; // packages/daisyui/components/card/index.js var card_default = ({ addComponents, prefix = "" }) => { const prefixedcard = addPrefix(object_default16, prefix); addComponents({ ...prefixedcard }); }; // packages/daisyui/components/steps/object.js var object_default17 = { ".steps": { display: "inline-grid", "grid-auto-flow": "column", overflow: "hidden", "overflow-x": "auto", "counter-reset": "step", "grid-auto-columns": "1fr", ".step": { display: "grid", "grid-template-columns": ["repeat(1, minmax(0, 1fr))", "auto"], "grid-template-rows": ["repeat(2, minmax(0, 1fr))", "40px 1fr"], "place-items": "center", "text-align": "center", "min-width": "4rem", "--step-bg": "var(--color-base-300)", "--step-fg": "var(--color-base-content)", "&:before": { top: "calc(0.25rem * 0)", "grid-column-start": "1", "grid-row-start": "1", height: "calc(0.25rem * 2)", width: "100%", border: "1px solid", color: "var(--step-bg)", "background-color": "var(--step-bg)", "--tw-content": '""', content: "var(--tw-content)", "margin-inline-start": "-100%" }, "> .step-icon, &:not(:has(.step-icon)):after": { content: "counter(step)", "counter-increment": "step", "z-index": 1, color: "var(--step-fg)", "background-color": "var(--step-bg)", border: "1px solid var(--step-bg)", position: "relative", "grid-column-start": "1", "grid-row-start": "1", display: "grid", height: "calc(0.25rem * 8)", width: "calc(0.25rem * 8)", "place-items": "center", "place-self": "center", "border-radius": "calc(infinity * 1px)" }, "&:first-child:before": { content: "none" }, "&[data-content]:after": { content: "attr(data-content)" } }, ".step-neutral": { "+ .step-neutral:before, &:after, > .step-icon": { "--step-bg": "var(--color-neutral)", "--step-fg": "var(--color-neutral-content)" } }, ".step-primary": { "+ .step-primary:before, &:after, > .step-icon": { "--step-bg": "var(--color-primary)", "--step-fg": "var(--color-primary-content)" } }, ".step-secondary": { "+ .step-secondary:before, &:after, > .step-icon": { "--step-bg": "var(--color-secondary)", "--step-fg": "var(--color-secondary-content)" } }, ".step-accent": { "+ .step-accent:before, &:after, > .step-icon": { "--step-bg": "var(--color-accent)", "--step-fg": "var(--color-accent-content)" } }, ".step-info": { "+ .step-info:before, &:after, > .step-icon": { "--step-bg": "var(--color-info)", "--step-fg": "var(--color-info-content)" } }, ".step-success": { "+ .step-success:before, &:after, > .step-icon": { "--step-bg": "var(--color-success)", "--step-fg": "var(--color-success-content)" } }, ".step-warning": { "+ .step-warning:before, &:after, > .step-icon": { "--step-bg": "var(--color-warning)", "--step-fg": "var(--color-warning-content)" } }, ".step-error": { "+ .step-error:before, &:after, > .step-icon": { "--step-bg": "var(--color-error)", "--step-fg": "var(--color-error-content)" } } }, ".steps-horizontal": { "grid-auto-columns": "1fr", display: "inline-grid", "grid-auto-flow": "column", overflow: "hidden", "overflow-x": "auto", ".step": { display: "grid", "grid-template-columns": ["repeat(1, minmax(0, 1fr))", "auto"], "grid-template-rows": ["repeat(2, minmax(0, 1fr))", "40px 1fr"], "place-items": "center", "text-align": "center", "min-width": "4rem", "&:before": { height: "calc(0.25rem * 2)", width: "100%", translate: "0", content: '""', "margin-inline-start": "-100%" }, '[dir="rtl"] &:before': { translate: "0" } } }, ".steps-vertical": { "grid-auto-rows": "1fr", "grid-auto-flow": "row", ".step": { display: "grid", "grid-template-columns": ["repeat(2, minmax(0, 1fr))", "40px 1fr"], "grid-template-rows": ["repeat(1, minmax(0, 1fr))", "auto"], gap: "0.5rem", "min-height": "4rem", "justify-items": "start", "&:before": { height: "100%", width: "calc(0.25rem * 2)", translate: "-50% -50%", "margin-inline-start": "50%" }, '[dir="rtl"] &:before': { translate: "50% -50%" } } } }; // packages/daisyui/components/steps/index.js var steps_default = ({ addComponents, prefix = "" }) => { const prefixedsteps = addPrefix(object_default17, prefix); addComponents({ ...prefixedsteps }); }; // packages/daisyui/components/alert/object.js var object_default18 = { ".alert": { display: "grid", "align-items": "center", gap: "calc(0.25rem * 4)", "border-radius": "var(--radius-box)", "padding-inline": "calc(0.25rem * 4)", "padding-block": "calc(0.25rem * 3)", color: "var(--color-base-content)", "background-color": "var(--alert-color, var(--color-base-200))", "justify-content": "start", "justify-items": "start", "grid-auto-flow": "column", "grid-template-columns": "auto", "text-align": "start", border: "var(--border) solid var(--color-base-200)", "font-size": "0.875rem", "line-height": "1.25rem", "background-size": "auto, calc(var(--noise) * 100%)", "background-image": "none, var(--fx-noise)", "box-shadow": "0 3px 0 -2px oklch(100% 0 0 / calc(var(--depth) * 0.08)) inset, 0 1px color-mix( in oklab, color-mix(in oklab, #000 20%, var(--alert-color, var(--color-base-200))) calc(var(--depth) * 20%), #0000 ), 0 4px 3px -2px oklch(0% 0 0 / calc(var(--depth) * 0.08))", "&:has(:nth-child(2))": { "grid-template-columns": "auto minmax(auto, 1fr)" }, "&.alert-outline": { "background-color": "transparent", color: "var(--alert-color)", "box-shadow": "none", "background-image": "none" }, "&.alert-dash": { "background-color": "transparent", color: "var(--alert-color)", "border-style": "dashed", "box-shadow": "none", "background-image": "none" }, "&.alert-soft": { color: "var(--alert-color, var(--color-base-content))", background: "color-mix( in oklab, var(--alert-color, var(--color-base-content)) 8%, var(--color-base-100) )", "border-color": "color-mix( in oklab, var(--alert-color, var(--color-base-content)) 10%, var(--color-base-100) )", "box-shadow": "none", "background-image": "none" } }, ".alert-info": { "border-color": "var(--color-info)", color: "var(--color-info-content)", "--alert-color": "var(--color-info)" }, ".alert-success": { "border-color": "var(--color-success)", color: "var(--color-success-content)", "--alert-color": "var(--color-success)" }, ".alert-warning": { "border-color": "var(--color-warning)", color: "var(--color-warning-content)", "--alert-color": "var(--color-warning)" }, ".alert-error": { "border-color": "var(--color-error)", color: "var(--color-error-content)", "--alert-color": "var(--color-error)" }, ".alert-vertical": { "justify-content": "center", "justify-items": "center", "grid-auto-flow": "row", "grid-template-columns": "auto", "text-align": "center", "&:has(:nth-child(2))": { "grid-template-columns": "auto" } }, ".alert-horizontal": { "justify-content": "start", "justify-items": "start", "grid-auto-flow": "column", "grid-template-columns": "auto", "text-align": "start", "&:has(:nth-child(2))": { "grid-template-columns": "auto minmax(auto, 1fr)" } } }; // packages/daisyui/components/alert/index.js var alert_default = ({ addComponents, prefix = "" }) => { const prefixedalert = addPrefix(object_default18, prefix); addComponents({ ...prefixedalert }); }; // packages/daisyui/components/kbd/object.js var object_default19 = { ".kbd": { display: "inline-flex", "align-items": "center", "justify-content": "center", "border-radius": "var(--radius-field)", "background-color": "var(--color-base-200)", "vertical-align": "middle", "padding-left": "0.5em", "padding-right": "0.5em", border: "var(--border) solid color-mix(in srgb, var(--color-base-content) 20%, #0000)", "border-bottom": "calc(var(--border) + 1px) solid color-mix(in srgb, var(--color-base-content) 20%, #0000)", "--size": "calc(var(--size-selector, 0.25rem) * 6)", "font-size": "0.875rem", height: "var(--size)", "min-width": "var(--size)" }, ".kbd-xs": { "--size": "calc(var(--size-selector, 0.25rem) * 4)", "font-size": "0.625rem" }, ".kbd-sm": { "--size": "calc(var(--size-selector, 0.25rem) * 5)", "font-size": "0.75rem" }, ".kbd-md": { "--size": "calc(var(--size-selector, 0.25rem) * 6)", "font-size": "0.875rem" }, ".kbd-lg": { "--size": "calc(var(--size-selector, 0.25rem) * 7)", "font-size": "1rem" }, ".kbd-xl": { "--size": "calc(var(--size-selector, 0.25rem) * 8)", "font-size": "1.125rem" } }; // packages/daisyui/components/kbd/index.js var kbd_default = ({ addComponents, prefix = "" }) => { const prefixedkbd = addPrefix(object_default19, prefix); addComponents({ ...prefixedkbd }); }; // packages/daisyui/components/select/object.js var object_default20 = { ".select": { border: "var(--border) solid #0000", position: "relative", display: "inline-flex", "flex-shrink": 1, appearance: "none", "align-items": "center", gap: "calc(0.25rem * 1.5)", "background-color": "var(--color-base-100)", "padding-inline-start": "calc(0.25rem * 4)", "padding-inline-end": "calc(0.25rem * 7)", "vertical-align": "middle", width: "clamp(3rem, 20rem, 100%)", height: "var(--size)", "font-size": "0.875rem", "border-start-start-radius": "var(--join-ss, var(--radius-field))", "border-start-end-radius": "var(--join-se, var(--radius-field))", "border-end-start-radius": "var(--join-es, var(--radius-field))", "border-end-end-radius": "var(--join-ee, var(--radius-field))", "background-image": "linear-gradient(45deg, #0000 50%, currentColor 50%), linear-gradient(135deg, currentColor 50%, #0000 50%)", "background-position": "calc(100% - 20px) calc(1px + 50%), calc(100% - 16.1px) calc(1px + 50%)", "background-size": "4px 4px, 4px 4px", "background-repeat": "no-repeat", "text-overflow": "ellipsis", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000) inset, 0 -1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset", "border-color": "var(--input-color)", "--input-color": "color-mix(in oklab, var(--color-base-content) 20%, #0000)", "--size": "calc(var(--size-field, 0.25rem) * 10)", '[dir="rtl"] &': { "background-position": "calc(0% + 12px) calc(1px + 50%), calc(0% + 16px) calc(1px + 50%)" }, select: { "margin-inline-start": "calc(0.25rem * -4)", "margin-inline-end": "calc(0.25rem * -7)", width: "calc(100% + 2.75rem)", appearance: "none", "padding-inline-start": "calc(0.25rem * 4)", "padding-inline-end": "calc(0.25rem * 7)", height: "calc(100% - 2px)", background: "inherit", "border-radius": "inherit", "border-style": "none", "&:focus, &:focus-within": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } }, "&:not(:last-child)": { "margin-inline-end": "calc(0.25rem * -5.5)", "background-image": "none" } }, "&:focus, &:focus-within": { "--input-color": "var(--color-base-content)", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000)", outline: "2px solid var(--input-color)", "outline-offset": "2px", isolation: "isolate", "z-index": 1 }, "&:has(> select[disabled]), &:is(:disabled, [disabled])": { cursor: "not-allowed", "border-color": "var(--color-base-200)", "background-color": "var(--color-base-200)", color: "color-mix(in oklab, var(--color-base-content) 40%, transparent)", "&::placeholder": { color: "color-mix(in oklab, var(--color-base-content) 20%, transparent)" } }, "&:has(> select[disabled]) > select[disabled]": { cursor: "not-allowed" } }, ".select-ghost": { "background-color": "transparent", transition: "background-color 0.2s", "box-shadow": "none", "border-color": "#0000", "&:focus, &:focus-within": { "background-color": "var(--color-base-100)", color: "var(--color-base-content)", "border-color": "#0000", "box-shadow": "none" } }, ".select-neutral": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-neutral)" } }, ".select-primary": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-primary)" } }, ".select-secondary": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-secondary)" } }, ".select-accent": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-accent)" } }, ".select-info": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-info)" } }, ".select-success": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-success)" } }, ".select-warning": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-warning)" } }, ".select-error": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-error)" } }, ".select-xs": { "--size": "calc(var(--size-field, 0.25rem) * 6)", "font-size": "0.6875rem" }, ".select-sm": { "--size": "calc(var(--size-field, 0.25rem) * 8)", "font-size": "0.75rem" }, ".select-md": { "--size": "calc(var(--size-field, 0.25rem) * 10)", "font-size": "0.875rem" }, ".select-lg": { "--size": "calc(var(--size-field, 0.25rem) * 12)", "font-size": "1.125rem" }, ".select-xl": { "--size": "calc(var(--size-field, 0.25rem) * 14)", "font-size": "1.375rem" } }; // packages/daisyui/components/select/index.js var select_default = ({ addComponents, prefix = "" }) => { const prefixedselect = addPrefix(object_default20, prefix); addComponents({ ...prefixedselect }); }; // packages/daisyui/components/progress/object.js var object_default21 = { ".progress": { position: "relative", height: "calc(0.25rem * 2)", width: "100%", appearance: "none", overflow: "hidden", "border-radius": "var(--radius-box)", "background-color": "color-mix(in oklab, currentColor 20%, transparent)", color: "var(--color-base-content)", "&:indeterminate": { "background-image": "repeating-linear-gradient( 90deg, currentColor -1%, currentColor 10%, #0000 10%, #0000 90% )", "background-size": "200%", "background-position-x": "15%", animation: "progress 5s ease-in-out infinite", "@supports (-moz-appearance: none)": { "&::-moz-progress-bar": { "background-color": "transparent", "background-image": "repeating-linear-gradient( 90deg, currentColor -1%, currentColor 10%, #0000 10%, #0000 90% )", "background-size": "200%", "background-position-x": "15%", animation: "progress 5s ease-in-out infinite" } } }, "@supports (-moz-appearance: none)": { "&::-moz-progress-bar": { "border-radius": "var(--radius-box)", "background-color": "currentColor" } }, "@supports (-webkit-appearance: none)": { "&::-webkit-progress-bar": { "border-radius": "var(--radius-box)", "background-color": "transparent" }, "&::-webkit-progress-value": { "border-radius": "var(--radius-box)", "background-color": "currentColor" } } }, ".progress-primary": { color: "var(--color-primary)" }, ".progress-secondary": { color: "var(--color-secondary)" }, ".progress-accent": { color: "var(--color-accent)" }, ".progress-neutral": { color: "var(--color-neutral)" }, ".progress-info": { color: "var(--color-info)" }, ".progress-success": { color: "var(--color-success)" }, ".progress-warning": { color: "var(--color-warning)" }, ".progress-error": { color: "var(--color-error)" }, "@keyframes progress": { "50%": { "background-position-x": "-115%" } } }; // packages/daisyui/components/progress/index.js var progress_default = ({ addComponents, prefix = "" }) => { const prefixedprogress = addPrefix(object_default21, prefix); addComponents({ ...prefixedprogress }); }; // packages/daisyui/components/fileinput/object.js var object_default22 = { ".file-input": { cursor: ["pointer", "pointer"], border: "var(--border) solid #0000", display: "inline-flex", appearance: "none", "align-items": "center", "background-color": "var(--color-base-100)", "vertical-align": "middle", "webkit-user-select": "none", "user-select": "none", width: "clamp(3rem, 20rem, 100%)", height: "var(--size)", "padding-inline-end": "0.75rem", "font-size": "0.875rem", "line-height": 2, "border-start-start-radius": "var(--join-ss, var(--radius-field))", "border-start-end-radius": "var(--join-se, var(--radius-field))", "border-end-start-radius": "var(--join-es, var(--radius-field))", "border-end-end-radius": "var(--join-ee, var(--radius-field))", "border-color": "var(--input-color)", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000) inset, 0 -1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset", "--size": "calc(var(--size-field, 0.25rem) * 10)", "--input-color": "color-mix(in oklab, var(--color-base-content) 20%, #0000)", "&::file-selector-button": { "margin-inline-end": "calc(0.25rem * 4)", cursor: "pointer", "padding-inline": "calc(0.25rem * 4)", "webkit-user-select": "none", "user-select": "none", height: "calc(100% + var(--border) * 2)", "margin-block": "calc(var(--border) * -1)", "margin-inline-start": "calc(var(--border) * -1)", "font-size": "0.875rem", color: "var(--btn-fg)", "border-width": "var(--border)", "border-style": "solid", "border-color": "var(--btn-border)", "border-start-start-radius": "calc(var(--join-ss, var(--radius-field) - var(--border)))", "border-end-start-radius": "calc(var(--join-es, var(--radius-field) - var(--border)))", "font-weight": 600, "background-color": "var(--btn-bg)", "background-size": "calc(var(--noise) * 100%)", "background-image": "var(--btn-noise)", "text-shadow": "0 0.5px oklch(1 0 0 / calc(var(--depth) * 0.15))", "box-shadow": "0 0.5px 0 0.5px color-mix( in oklab, color-mix(in oklab, white 30%, var(--btn-bg)) calc(var(--depth) * 20%), #0000 ) inset, var(--btn-shadow)", "--size": "calc(var(--size-field, 0.25rem) * 10)", "--btn-bg": "var(--btn-color, var(--color-base-200))", "--btn-fg": "var(--color-base-content)", "--btn-border": "color-mix(in oklab, var(--btn-bg), #000 5%)", "--btn-shadow": `0 3px 2px -2px color-mix(in oklab, var(--btn-bg) 30%, #0000), 0 4px 3px -2px color-mix(in oklab, var(--btn-bg) 30%, #0000)`, "--btn-noise": "var(--fx-noise)" }, "&:focus": { "--input-color": "var(--color-base-content)", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) 10%, #0000)", outline: "2px solid var(--input-color)", "outline-offset": "2px", isolation: "isolate" }, "&:has(> input[disabled]), &:is(:disabled, [disabled])": { cursor: "not-allowed", "border-color": "var(--color-base-200)", "background-color": "var(--color-base-200)", "&::placeholder": { color: "color-mix(in oklab, var(--color-base-content) 20%, transparent)" }, "box-shadow": "none", color: "color-mix(in oklch, var(--color-base-content) 20%, #0000)", "&::file-selector-button": { cursor: "not-allowed", "border-color": "var(--color-base-200)", "background-color": "var(--color-base-200)", "--btn-border": "#0000", "--btn-noise": "none", "--btn-fg": "color-mix(in oklch, var(--color-base-content) 20%, #0000)" } } }, ".file-input-ghost": { "background-color": "transparent", transition: "background-color 0.2s", "box-shadow": "none", "border-color": "#0000", "&::file-selector-button": { "margin-inline-start": "calc(0.25rem * 0)", "margin-inline-end": "calc(0.25rem * 4)", height: "100%", cursor: "pointer", "padding-inline": "calc(0.25rem * 4)", "webkit-user-select": "none", "user-select": "none", "margin-block": "0", "border-start-end-radius": "calc(var(--join-ss, var(--radius-field) - var(--border)))", "border-end-end-radius": "calc(var(--join-es, var(--radius-field) - var(--border)))" }, "&:focus, &:focus-within": { "background-color": "var(--color-base-100)", color: "var(--color-base-content)", "border-color": "#0000", "box-shadow": "none" } }, ".file-input-neutral": { "--btn-color": "var(--color-neutral)", "&::file-selector-button": { color: "var(--color-neutral-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-neutral)" } }, ".file-input-primary": { "--btn-color": "var(--color-primary)", "&::file-selector-button": { color: "var(--color-primary-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-primary)" } }, ".file-input-secondary": { "--btn-color": "var(--color-secondary)", "&::file-selector-button": { color: "var(--color-secondary-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-secondary)" } }, ".file-input-accent": { "--btn-color": "var(--color-accent)", "&::file-selector-button": { color: "var(--color-accent-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-accent)" } }, ".file-input-info": { "--btn-color": "var(--color-info)", "&::file-selector-button": { color: "var(--color-info-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-info)" } }, ".file-input-success": { "--btn-color": "var(--color-success)", "&::file-selector-button": { color: "var(--color-success-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-success)" } }, ".file-input-warning": { "--btn-color": "var(--color-warning)", "&::file-selector-button": { color: "var(--color-warning-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-warning)" } }, ".file-input-error": { "--btn-color": "var(--color-error)", "&::file-selector-button": { color: "var(--color-error-content)" }, "&, &:focus, &:focus-within": { "--input-color": "var(--color-error)" } }, ".file-input-xs": { "--size": "calc(var(--size-field, 0.25rem) * 6)", "font-size": "0.6875rem", "line-height": "1rem", "&::file-selector-button": { "font-size": "0.6875rem" } }, ".file-input-sm": { "--size": "calc(var(--size-field, 0.25rem) * 8)", "font-size": "0.75rem", "line-height": "1.5rem", "&::file-selector-button": { "font-size": "0.75rem" } }, ".file-input-md": { "--size": "calc(var(--size-field, 0.25rem) * 10)", "font-size": "0.875rem", "line-height": 2, "&::file-selector-button": { "font-size": "0.875rem" } }, ".file-input-lg": { "--size": "calc(var(--size-field, 0.25rem) * 12)", "font-size": "1.125rem", "line-height": "2.5rem", "&::file-selector-button": { "font-size": "1.125rem" } }, ".file-input-xl": { "padding-inline-end": "calc(0.25rem * 6)", "--size": "calc(var(--size-field, 0.25rem) * 14)", "font-size": "1.125rem", "line-height": "3rem", "&::file-selector-button": { "font-size": "1.375rem" } } }; // packages/daisyui/components/fileinput/index.js var fileinput_default = ({ addComponents, prefix = "" }) => { const prefixedfileinput = addPrefix(object_default22, prefix); addComponents({ ...prefixedfileinput }); }; // packages/daisyui/components/modal/object.js var object_default23 = { ".modal": { "pointer-events": "none", visibility: "hidden", position: "fixed", inset: "calc(0.25rem * 0)", margin: "calc(0.25rem * 0)", display: "grid", height: "100%", "max-height": "none", width: "100%", "max-width": "none", "align-items": "center", "justify-items": "center", "background-color": "transparent", padding: "calc(0.25rem * 0)", color: "inherit", "overflow-x": "hidden", transition: "translate 0.3s ease-out, visibility 0.3s allow-discrete, background-color 0.3s ease-out, opacity 0.1s ease-out", "overflow-y": "hidden", "overscroll-behavior": "contain", "z-index": 999, "&::backdrop": { display: "none" }, "&.modal-open, &[open], &:target": { "pointer-events": "auto", visibility: "visible", opacity: "100%", "background-color": "oklch(0% 0 0/ 0.4)", ".modal-box": { translate: "0 0", scale: "1", opacity: 1 } }, "@starting-style": { "&.modal-open, &[open], &:target": { visibility: "hidden", opacity: "0%" } } }, ".modal-action": { "margin-top": "calc(0.25rem * 6)", display: "flex", "justify-content": "flex-end", gap: "calc(0.25rem * 2)" }, ".modal-toggle": { position: "fixed", height: "calc(0.25rem * 0)", width: "calc(0.25rem * 0)", appearance: "none", opacity: "0%", "&:checked + .modal": { "pointer-events": "auto", visibility: "visible", opacity: "100%", "background-color": "oklch(0% 0 0/ 0.4)", ".modal-box": { translate: "0 0", scale: "1", opacity: 1 } }, "@starting-style": { "&:checked + .modal": { visibility: "hidden", opacity: "0%" } } }, ".modal-backdrop": { "grid-column-start": "1", "grid-row-start": "1", display: "grid", "align-self": "stretch", "justify-self": "stretch", color: "transparent", "z-index": -1, button: { cursor: "pointer" } }, ".modal-box": { "grid-column-start": "1", "grid-row-start": "1", "max-height": "100vh", width: "calc(11/12 * 100%)", "max-width": "32rem", "background-color": "var(--color-base-100)", padding: "calc(0.25rem * 6)", transition: "translate 0.3s ease-out, scale 0.3s ease-out, opacity 0.2s ease-out 0.05s, box-shadow 0.3s ease-out", "border-top-left-radius": "var(--modal-tl, var(--radius-box))", "border-top-right-radius": "var(--modal-tr, var(--radius-box))", "border-bottom-left-radius": "var(--modal-bl, var(--radius-box))", "border-bottom-right-radius": "var(--modal-br, var(--radius-box))", scale: "95%", opacity: 0, "box-shadow": "oklch(0% 0 0/ 0.25) 0px 25px 50px -12px", "overflow-y": "auto", "overscroll-behavior": "contain" }, ".modal-top": { "place-items": "start", ":where(.modal-box)": { height: "auto", width: "100%", "max-width": "none", "max-height": "calc(100vh - 5em)", translate: "0 -100%", scale: "1", "--modal-tl": "0", "--modal-tr": "0", "--modal-bl": "var(--radius-box)", "--modal-br": "var(--radius-box)" } }, ".modal-middle": { "place-items": "center", ":where(.modal-box)": { height: "auto", width: "calc(11/12 * 100%)", "max-width": "32rem", "max-height": "calc(100vh - 5em)", translate: "0 2%", scale: "98%", "--modal-tl": "var(--radius-box)", "--modal-tr": "var(--radius-box)", "--modal-bl": "var(--radius-box)", "--modal-br": "var(--radius-box)" } }, ".modal-bottom": { "place-items": "end", ":where(.modal-box)": { height: "auto", width: "100%", "max-width": "none", "max-height": "calc(100vh - 5em)", translate: "0 100%", scale: "1", "--modal-tl": "var(--radius-box)", "--modal-tr": "var(--radius-box)", "--modal-bl": "0", "--modal-br": "0" } }, ".modal-start": { "place-items": "start", ":where(.modal-box)": { height: "100vh", "max-height": "none", width: "auto", "max-width": "none", translate: "-100% 0", scale: "1", "--modal-tl": "0", "--modal-tr": "var(--radius-box)", "--modal-bl": "0", "--modal-br": "var(--radius-box)" } }, ".modal-end": { "place-items": "end", ":where(.modal-box)": { height: "100vh", "max-height": "none", width: "auto", "max-width": "none", translate: "100% 0", scale: "1", "--modal-tl": "var(--radius-box)", "--modal-tr": "0", "--modal-bl": "var(--radius-box)", "--modal-br": "0" } } }; // packages/daisyui/components/modal/index.js var modal_default = ({ addComponents, prefix = "" }) => { const prefixedmodal = addPrefix(object_default23, prefix); addComponents({ ...prefixedmodal }); }; // packages/daisyui/components/footer/object.js var object_default24 = { ".footer": { display: "grid", width: "100%", "grid-auto-flow": "row", "place-items": "start", "column-gap": "calc(0.25rem * 4)", "row-gap": "calc(0.25rem * 10)", "font-size": "0.875rem", "line-height": "1.25rem", "& > *": { display: "grid", "place-items": "start", gap: "calc(0.25rem * 2)" }, "&.footer-center": { "grid-auto-flow": "column dense", "place-items": "center", "text-align": "center", "& > *": { "place-items": "center" } } }, ".footer-title": { "margin-bottom": "calc(0.25rem * 2)", "text-transform": "uppercase", opacity: "60%", "font-weight": 600 }, ".footer-horizontal": { "grid-auto-flow": "column", "&.footer-center": { "grid-auto-flow": "row dense" } }, ".footer-vertical": { "grid-auto-flow": "row", "&.footer-center": { "grid-auto-flow": "column dense" } } }; // packages/daisyui/components/footer/index.js var footer_default = ({ addComponents, prefix = "" }) => { const prefixedfooter = addPrefix(object_default24, prefix); addComponents({ ...prefixedfooter }); }; // packages/daisyui/components/table/object.js var object_default25 = { ".table": { "font-size": "0.875rem", position: "relative", width: "100%", "border-radius": "var(--radius-box)", "text-align": "left", '&:where(:dir(rtl), [dir="rtl"], [dir="rtl"] *)': { "text-align": "right" }, "tr.row-hover": { "&, &:nth-child(even)": { "&:hover": { "@media (hover: hover)": { "background-color": "var(--color-base-200)" } } } }, ":where(th, td)": { "padding-inline": "calc(0.25rem * 4)", "padding-block": "calc(0.25rem * 3)", "vertical-align": "middle" }, ":where(thead, tfoot)": { "white-space": "nowrap", color: "color-mix(in oklab, var(--color-base-content) 60%, transparent)", "font-size": "0.875rem", "font-weight": 600 }, ":where(tfoot)": { "border-top": "var(--border) solid color-mix(in oklch, var(--color-base-content) 5%, #0000)" }, ":where(.table-pin-rows thead tr)": { position: "sticky", top: "calc(0.25rem * 0)", "z-index": 1, "background-color": "var(--color-base-100)" }, ":where(.table-pin-rows tfoot tr)": { position: "sticky", bottom: "calc(0.25rem * 0)", "z-index": 1, "background-color": "var(--color-base-100)" }, ":where(.table-pin-cols tr th)": { position: "sticky", right: "calc(0.25rem * 0)", left: "calc(0.25rem * 0)", "background-color": "var(--color-base-100)" }, ":where(thead tr, tbody tr:not(:last-child))": { "border-bottom": "var(--border) solid color-mix(in oklch, var(--color-base-content) 5%, #0000)" } }, ".table-zebra": { tbody: { tr: { "&:where(:nth-child(even))": { "background-color": "var(--color-base-200)", ":where(.table-pin-cols tr th)": { "background-color": "var(--color-base-200)" } }, "&.row-hover": { "&, &:where(:nth-child(even))": { "&:hover": { "@media (hover: hover)": { "background-color": "var(--color-base-300)" } } } } } } }, ".table-xs": { ":not(thead, tfoot) tr": { "font-size": "0.6875rem" }, ":where(th, td)": { "padding-inline": "calc(0.25rem * 2)", "padding-block": "calc(0.25rem * 1)" } }, ".table-sm": { ":not(thead, tfoot) tr": { "font-size": "0.75rem" }, ":where(th, td)": { "padding-inline": "calc(0.25rem * 3)", "padding-block": "calc(0.25rem * 2)" } }, ".table-md": { ":not(thead, tfoot) tr": { "font-size": "0.875rem" }, ":where(th, td)": { "padding-inline": "calc(0.25rem * 4)", "padding-block": "calc(0.25rem * 3)" } }, ".table-lg": { ":not(thead, tfoot) tr": { "font-size": "1.125rem" }, ":where(th, td)": { "padding-inline": "calc(0.25rem * 5)", "padding-block": "calc(0.25rem * 4)" } }, ".table-xl": { ":not(thead, tfoot) tr": { "font-size": "1.375rem" }, ":where(th, td)": { "padding-inline": "calc(0.25rem * 6)", "padding-block": "calc(0.25rem * 5)" } } }; // packages/daisyui/components/table/index.js var table_default = ({ addComponents, prefix = "" }) => { const prefixedtable = addPrefix(object_default25, prefix); addComponents({ ...prefixedtable }); }; // packages/daisyui/components/avatar/object.js var object_default26 = { ".avatar-group": { display: "flex", overflow: "hidden", ":where(.avatar)": { overflow: "hidden", "border-radius": "calc(infinity * 1px)", border: "4px solid var(--color-base-100)" } }, ".avatar": { position: "relative", display: "inline-flex", "vertical-align": "middle", "& > div": { display: "block", "aspect-ratio": "1 / 1", overflow: "hidden" }, img: { height: "100%", width: "100%", "object-fit": "cover" } }, ".avatar-placeholder": { "& > div": { display: "flex", "align-items": "center", "justify-content": "center" } }, ".avatar-online": { "&:before": { content: '""', position: "absolute", "z-index": 1, display: "block", "border-radius": "calc(infinity * 1px)", "background-color": "var(--color-success)", outline: "2px solid var(--color-base-100)", width: "15%", height: "15%", top: "7%", right: "7%" } }, ".avatar-offline": { "&:before": { content: '""', position: "absolute", "z-index": 1, display: "block", "border-radius": "calc(infinity * 1px)", "background-color": "var(--color-base-300)", outline: "2px solid var(--color-base-100)", width: "15%", height: "15%", top: "7%", right: "7%" } } }; // packages/daisyui/components/avatar/index.js var avatar_default = ({ addComponents, prefix = "" }) => { const prefixedavatar = addPrefix(object_default26, prefix); addComponents({ ...prefixedavatar }); }; // packages/daisyui/components/input/object.js var object_default27 = { ".input": { cursor: "text", border: "var(--border) solid #0000", position: "relative", display: "inline-flex", "flex-shrink": 1, appearance: "none", "align-items": "center", gap: "calc(0.25rem * 2)", "background-color": "var(--color-base-100)", "padding-inline": "calc(0.25rem * 3)", "vertical-align": "middle", "white-space": "nowrap", width: "clamp(3rem, 20rem, 100%)", height: "var(--size)", "font-size": "0.875rem", "border-start-start-radius": "var(--join-ss, var(--radius-field))", "border-start-end-radius": "var(--join-se, var(--radius-field))", "border-end-start-radius": "var(--join-es, var(--radius-field))", "border-end-end-radius": "var(--join-ee, var(--radius-field))", "border-color": "var(--input-color)", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000) inset, 0 -1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset", "--size": "calc(var(--size-field, 0.25rem) * 10)", "--input-color": "color-mix(in oklab, var(--color-base-content) 20%, #0000)", "&:where(input)": { display: "inline-flex" }, ":where(input)": { display: "inline-flex", height: "100%", width: "100%", appearance: "none", "background-color": "transparent", border: "none", "&:focus, &:focus-within": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } } }, ':where(input[type="date"])': { display: "inline-block" }, "&:focus, &:focus-within": { "--input-color": "var(--color-base-content)", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000)", outline: "2px solid var(--input-color)", "outline-offset": "2px", isolation: "isolate", "z-index": 1 }, "&:has(> input[disabled]), &:is(:disabled, [disabled])": { cursor: "not-allowed", "border-color": "var(--color-base-200)", "background-color": "var(--color-base-200)", color: "color-mix(in oklab, var(--color-base-content) 40%, transparent)", "&::placeholder": { color: "color-mix(in oklab, var(--color-base-content) 20%, transparent)" }, "box-shadow": "none" }, "&:has(> input[disabled]) > input[disabled]": { cursor: "not-allowed" }, "&::-webkit-date-and-time-value": { "text-align": "inherit" }, '&[type="number"]': { "&::-webkit-inner-spin-button": { "margin-block": "calc(0.25rem * -3)", "margin-inline-end": "calc(0.25rem * -3)" } }, "&::-webkit-calendar-picker-indicator": { position: "absolute", "inset-inline-end": "0.75em" } }, ".input-ghost": { "background-color": "transparent", "box-shadow": "none", "border-color": "#0000", "&:focus, &:focus-within": { "background-color": "var(--color-base-100)", color: "var(--color-base-content)", "border-color": "#0000", "box-shadow": "none" } }, ".input-neutral": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-neutral)" } }, ".input-primary": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-primary)" } }, ".input-secondary": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-secondary)" } }, ".input-accent": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-accent)" } }, ".input-info": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-info)" } }, ".input-success": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-success)" } }, ".input-warning": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-warning)" } }, ".input-error": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-error)" } }, ".input-xs": { "--size": "calc(var(--size-field, 0.25rem) * 6)", "font-size": "0.6875rem", '&[type="number"]': { "&::-webkit-inner-spin-button": { "margin-block": "calc(0.25rem * -1)", "margin-inline-end": "calc(0.25rem * -3)" } } }, ".input-sm": { "--size": "calc(var(--size-field, 0.25rem) * 8)", "font-size": "0.75rem", '&[type="number"]': { "&::-webkit-inner-spin-button": { "margin-block": "calc(0.25rem * -2)", "margin-inline-end": "calc(0.25rem * -3)" } } }, ".input-md": { "--size": "calc(var(--size-field, 0.25rem) * 10)", "font-size": "0.875rem", '&[type="number"]': { "&::-webkit-inner-spin-button": { "margin-block": "calc(0.25rem * -3)", "margin-inline-end": "calc(0.25rem * -3)" } } }, ".input-lg": { "--size": "calc(var(--size-field, 0.25rem) * 12)", "font-size": "1.125rem", '&[type="number"]': { "&::-webkit-inner-spin-button": { "margin-block": "calc(0.25rem * -3)", "margin-inline-end": "calc(0.25rem * -3)" } } }, ".input-xl": { "--size": "calc(var(--size-field, 0.25rem) * 14)", "font-size": "1.375rem", '&[type="number"]': { "&::-webkit-inner-spin-button": { "margin-block": "calc(0.25rem * -4)", "margin-inline-end": "calc(0.25rem * -3)" } } } }; // packages/daisyui/components/input/index.js var input_default = ({ addComponents, prefix = "" }) => { const prefixedinput = addPrefix(object_default27, prefix); addComponents({ ...prefixedinput }); }; // packages/daisyui/components/checkbox/object.js var object_default28 = { ".checkbox": { border: "var(--border) solid var(--input-color, color-mix(in oklab, var(--color-base-content) 20%, #0000))", position: "relative", "flex-shrink": 0, cursor: "pointer", appearance: "none", "border-radius": "var(--radius-selector)", padding: "calc(0.25rem * 1)", "vertical-align": "middle", color: "var(--color-base-content)", "box-shadow": "0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 0 #0000 inset, 0 0 #0000", transition: "background-color 0.2s, box-shadow 0.2s", "--size": "calc(var(--size-selector, 0.25rem) * 6)", width: "var(--size)", height: "var(--size)", "background-size": "auto, calc(var(--noise) * 100%)", "background-image": "none, var(--fx-noise)", "&:before": { "--tw-content": '""', content: "var(--tw-content)", display: "block", width: "100%", height: "100%", rotate: "45deg", "background-color": "currentColor", opacity: "0%", transition: "clip-path 0.3s, opacity 0.1s, rotate 0.3s, translate 0.3s", "transition-delay": "0.1s", "clip-path": "polygon(20% 100%, 20% 80%, 50% 80%, 50% 80%, 70% 80%, 70% 100%)", "box-shadow": "0px 3px 0 0px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset", "font-size": "1rem", "line-height": 0.75 }, "&:focus-visible": { outline: "2px solid var(--input-color, currentColor)", "outline-offset": "2px" }, '&:checked, &[aria-checked="true"]': { "background-color": "var(--input-color, #0000)", "box-shadow": "0 0 #0000 inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1))", "&:before": { "clip-path": "polygon(20% 100%, 20% 80%, 50% 80%, 50% 0%, 70% 0%, 70% 100%)", opacity: "100%" }, "@media (forced-colors: active)": { "&:before": { rotate: "0deg", "background-color": "transparent", "--tw-content": '"✔︎"', "clip-path": "none" } }, "@media print": { "&:before": { rotate: "0deg", "background-color": "transparent", "--tw-content": '"✔︎"', "clip-path": "none" } } }, "&:indeterminate": { "&:before": { rotate: "0deg", opacity: "100%", translate: "0 -35%", "clip-path": "polygon(20% 100%, 20% 80%, 50% 80%, 50% 80%, 80% 80%, 80% 100%)" } } }, ".checkbox-primary": { color: "var(--color-primary-content)", "--input-color": "var(--color-primary)" }, ".checkbox-secondary": { color: "var(--color-secondary-content)", "--input-color": "var(--color-secondary)" }, ".checkbox-accent": { color: "var(--color-accent-content)", "--input-color": "var(--color-accent)" }, ".checkbox-neutral": { color: "var(--color-neutral-content)", "--input-color": "var(--color-neutral)" }, ".checkbox-info": { color: "var(--color-info-content)", "--input-color": "var(--color-info)" }, ".checkbox-success": { color: "var(--color-success-content)", "--input-color": "var(--color-success)" }, ".checkbox-warning": { color: "var(--color-warning-content)", "--input-color": "var(--color-warning)" }, ".checkbox-error": { color: "var(--color-error-content)", "--input-color": "var(--color-error)" }, ".checkbox:disabled": { cursor: "not-allowed", opacity: "20%" }, ".checkbox-xs": { padding: "0.125rem", "--size": "calc(var(--size-selector, 0.25rem) * 4)" }, ".checkbox-sm": { padding: "0.1875rem", "--size": "calc(var(--size-selector, 0.25rem) * 5)" }, ".checkbox-md": { padding: "0.25rem", "--size": "calc(var(--size-selector, 0.25rem) * 6)" }, ".checkbox-lg": { padding: "0.3125rem", "--size": "calc(var(--size-selector, 0.25rem) * 7)" }, ".checkbox-xl": { padding: "0.375rem", "--size": "calc(var(--size-selector, 0.25rem) * 8)" } }; // packages/daisyui/components/checkbox/index.js var checkbox_default = ({ addComponents, prefix = "" }) => { const prefixedcheckbox = addPrefix(object_default28, prefix); addComponents({ ...prefixedcheckbox }); }; // packages/daisyui/components/badge/object.js var object_default29 = { ".badge": { display: "inline-flex", "align-items": "center", "justify-content": "center", gap: "calc(0.25rem * 2)", "border-radius": "var(--radius-selector)", "vertical-align": "middle", color: "var(--badge-fg)", border: "var(--border) solid var(--badge-color, var(--color-base-200))", "font-size": "0.875rem", width: "fit-content", "padding-inline": "calc(0.25rem * 3 - var(--border))", "background-size": "auto, calc(var(--noise) * 100%)", "background-image": "none, var(--fx-noise)", "background-color": "var(--badge-bg)", "--badge-bg": "var(--badge-color, var(--color-base-100))", "--badge-fg": "var(--color-base-content)", "--size": "calc(var(--size-selector, 0.25rem) * 6)", height: "var(--size)", "&.badge-outline": { "--badge-fg": "var(--badge-color)", "--badge-bg": "#0000", "background-image": "none", "border-color": "currentColor" }, "&.badge-dash": { "--badge-fg": "var(--badge-color)", "--badge-bg": "#0000", "background-image": "none", "border-color": "currentColor", "border-style": "dashed" }, "&.badge-soft": { color: "var(--badge-color, var(--color-base-content))", "background-color": "color-mix( in oklab, var(--badge-color, var(--color-base-content)) 8%, var(--color-base-100) )", "border-color": "color-mix( in oklab, var(--badge-color, var(--color-base-content)) 10%, var(--color-base-100) )", "background-image": "none" } }, ".badge-primary": { "--badge-color": "var(--color-primary)", "--badge-fg": "var(--color-primary-content)" }, ".badge-secondary": { "--badge-color": "var(--color-secondary)", "--badge-fg": "var(--color-secondary-content)" }, ".badge-accent": { "--badge-color": "var(--color-accent)", "--badge-fg": "var(--color-accent-content)" }, ".badge-neutral": { "--badge-color": "var(--color-neutral)", "--badge-fg": "var(--color-neutral-content)" }, ".badge-info": { "--badge-color": "var(--color-info)", "--badge-fg": "var(--color-info-content)" }, ".badge-success": { "--badge-color": "var(--color-success)", "--badge-fg": "var(--color-success-content)" }, ".badge-warning": { "--badge-color": "var(--color-warning)", "--badge-fg": "var(--color-warning-content)" }, ".badge-error": { "--badge-color": "var(--color-error)", "--badge-fg": "var(--color-error-content)" }, ".badge-ghost": { "border-color": "var(--color-base-200)", "background-color": "var(--color-base-200)", color: "var(--color-base-content)", "background-image": "none" }, ".badge-xs": { "--size": "calc(var(--size-selector, 0.25rem) * 4)", "font-size": "0.625rem", "padding-inline": "calc(0.25rem * 2 - var(--border))" }, ".badge-sm": { "--size": "calc(var(--size-selector, 0.25rem) * 5)", "font-size": "0.75rem", "padding-inline": "calc(0.25rem * 2.5 - var(--border))" }, ".badge-md": { "--size": "calc(var(--size-selector, 0.25rem) * 6)", "font-size": "0.875rem", "padding-inline": "calc(0.25rem * 3 - var(--border))" }, ".badge-lg": { "--size": "calc(var(--size-selector, 0.25rem) * 7)", "font-size": "1rem", "padding-inline": "calc(0.25rem * 3.5 - var(--border))" }, ".badge-xl": { "--size": "calc(var(--size-selector, 0.25rem) * 8)", "font-size": "1.125rem", "padding-inline": "calc(0.25rem * 4 - var(--border))" } }; // packages/daisyui/components/badge/index.js var badge_default = ({ addComponents, prefix = "" }) => { const prefixedbadge = addPrefix(object_default29, prefix); addComponents({ ...prefixedbadge }); }; // packages/daisyui/components/status/object.js var object_default30 = { ".status": { display: "inline-block", "aspect-ratio": "1 / 1", width: "calc(0.25rem * 2)", height: "calc(0.25rem * 2)", "border-radius": "var(--radius-selector)", "background-color": "color-mix(in oklab, var(--color-base-content) 20%, transparent)", "background-position": "center", "background-repeat": "no-repeat", "vertical-align": "middle", color: "color-mix(in srgb, #000 30%, transparent)", "@supports (color: color-mix(in lab, red, red))": { color: "color-mix(in oklab, var(--color-black) 30%, transparent)" }, "background-image": "radial-gradient( circle at 35% 30%, oklch(1 0 0 / calc(var(--depth) * 0.5)), #0000 )", "box-shadow": "0 2px 3px -1px color-mix(in oklab, currentColor calc(var(--depth) * 100%), #0000)" }, ".status-primary": { "background-color": "var(--color-primary)", color: "var(--color-primary)" }, ".status-secondary": { "background-color": "var(--color-secondary)", color: "var(--color-secondary)" }, ".status-accent": { "background-color": "var(--color-accent)", color: "var(--color-accent)" }, ".status-neutral": { "background-color": "var(--color-neutral)", color: "var(--color-neutral)" }, ".status-info": { "background-color": "var(--color-info)", color: "var(--color-info)" }, ".status-success": { "background-color": "var(--color-success)", color: "var(--color-success)" }, ".status-warning": { "background-color": "var(--color-warning)", color: "var(--color-warning)" }, ".status-error": { "background-color": "var(--color-error)", color: "var(--color-error)" }, ".status-xs": { width: "calc(0.25rem * 0.5)", height: "calc(0.25rem * 0.5)" }, ".status-sm": { width: "calc(0.25rem * 1)", height: "calc(0.25rem * 1)" }, ".status-md": { width: "calc(0.25rem * 2)", height: "calc(0.25rem * 2)" }, ".status-lg": { width: "calc(0.25rem * 3)", height: "calc(0.25rem * 3)" }, ".status-xl": { width: "calc(0.25rem * 4)", height: "calc(0.25rem * 4)" } }; // packages/daisyui/components/status/index.js var status_default = ({ addComponents, prefix = "" }) => { const prefixedstatus = addPrefix(object_default30, prefix); addComponents({ ...prefixedstatus }); }; // packages/daisyui/components/diff/object.js var object_default31 = { ".diff": { position: "relative", display: "grid", width: "100%", overflow: "hidden", "webkit-user-select": "none", "user-select": "none", direction: "ltr", "container-type": "inline-size", "grid-template-columns": "auto 1fr", "&:focus-visible, &:has(.diff-item-1:focus-visible)": { "outline-style": "var(--tw-outline-style)", "outline-width": "2px", "outline-offset": "1px", "outline-color": "var(--color-base-content)" }, "&:focus-visible": { "outline-style": "var(--tw-outline-style)", "outline-width": "2px", "outline-offset": "1px", "outline-color": "var(--color-base-content)", ".diff-resizer": { "min-width": "90cqi", "max-width": "90cqi" } }, "&:has(.diff-item-2:focus-visible)": { "outline-style": "var(--tw-outline-style)", "outline-width": "2px", "outline-offset": "1px", ".diff-resizer": { "min-width": "10cqi", "max-width": "10cqi" } }, "@supports (-webkit-overflow-scrolling: touch) and (overflow: -webkit-paged-x)": { "&:focus": { ".diff-resizer": { "min-width": "10cqi", "max-width": "10cqi" } }, "&:has(.diff-item-1:focus)": { ".diff-resizer": { "min-width": "90cqi", "max-width": "90cqi" } } } }, ".diff-resizer": { position: "relative", top: "calc(1/2 * 100%)", "z-index": 1, "grid-column-start": "1", "grid-row-start": "1", height: "calc(0.25rem * 2)", width: "50cqi", "max-width": "calc(100cqi - 1rem)", "min-width": "1rem", resize: "horizontal", overflow: "hidden", opacity: "0%", transform: "scaleY(3) translate(0.35rem, 0.08rem)", cursor: "ew-resize", "transform-origin": "100% 100%", "clip-path": "inset(calc(100% - 0.75rem) 0 0 calc(100% - 0.75rem))", transition: "min-width 0.3s ease-out, max-width 0.3s ease-out" }, ".diff-item-2": { position: "relative", "grid-column-start": "1", "grid-row-start": "1", "&:after": { "pointer-events": "none", position: "absolute", top: "calc(1/2 * 100%)", right: "1px", bottom: "calc(0.25rem * 0)", "z-index": 2, "border-radius": "calc(infinity * 1px)", "background-color": "color-mix(in oklab, var(--color-base-100) 50%, transparent)", width: "1.2rem", height: "1.8rem", border: "2px solid var(--color-base-100)", content: '""', outline: "1px solid color-mix(in oklab, var(--color-base-content) 5%, #0000)", "outline-offset": "-3px", "backdrop-filter": "blur(8px)", "box-shadow": "0 1px 2px 0 oklch(0% 0 0 / 0.1)", translate: "50% -50%" }, "> *": { "pointer-events": "none", position: "absolute", top: "calc(0.25rem * 0)", bottom: "calc(0.25rem * 0)", left: "calc(0.25rem * 0)", height: "100%", width: "100cqi", "max-width": "none", "object-fit": "cover", "object-position": "center" }, "@supports (-webkit-overflow-scrolling: touch) and (overflow: -webkit-paged-x)": { "&:after": { content: "none" } } }, ".diff-item-1": { position: "relative", "z-index": 1, "grid-column-start": "1", "grid-row-start": "1", overflow: "hidden", "border-right": "2px solid var(--color-base-100)", "> *": { "pointer-events": "none", position: "absolute", top: "calc(0.25rem * 0)", bottom: "calc(0.25rem * 0)", left: "calc(0.25rem * 0)", height: "100%", width: "100cqi", "max-width": "none", "object-fit": "cover", "object-position": "center" } } }; // packages/daisyui/components/diff/index.js var diff_default = ({ addComponents, prefix = "" }) => { const prefixeddiff = addPrefix(object_default31, prefix); addComponents({ ...prefixeddiff }); }; // packages/daisyui/components/hero/object.js var object_default32 = { ".hero": { display: "grid", width: "100%", "place-items": "center", "background-size": "cover", "background-position": "center", "& > *": { "grid-column-start": "1", "grid-row-start": "1" } }, ".hero-overlay": { "grid-column-start": "1", "grid-row-start": "1", height: "100%", width: "100%", "background-color": "color-mix(in oklab, var(--color-neutral) 50%, transparent)" }, ".hero-content": { isolation: "isolate", display: "flex", "max-width": "80rem", "align-items": "center", "justify-content": "center", gap: "calc(0.25rem * 4)", padding: "calc(0.25rem * 4)" } }; // packages/daisyui/components/hero/index.js var hero_default = ({ addComponents, prefix = "" }) => { const prefixedhero = addPrefix(object_default32, prefix); addComponents({ ...prefixedhero }); }; // packages/daisyui/components/toggle/object.js var object_default33 = { ".toggle": { border: "var(--border) solid currentColor", color: "var(--input-color)", position: "relative", display: "inline-grid", "flex-shrink": 0, cursor: "pointer", appearance: "none", "place-content": "center", "vertical-align": "middle", "webkit-user-select": "none", "user-select": "none", "grid-template-columns": "0fr 1fr 1fr", "--radius-selector-max": `calc( var(--radius-selector) + var(--radius-selector) + var(--radius-selector) )`, "border-radius": "calc( var(--radius-selector) + min(var(--toggle-p), var(--radius-selector-max)) + min(var(--border), var(--radius-selector-max)) )", padding: "var(--toggle-p)", "box-shadow": "0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000) inset", transition: "color 0.3s, grid-template-columns 0.2s", "--input-color": "color-mix(in oklab, var(--color-base-content) 50%, #0000)", "--toggle-p": "calc(var(--size) * 0.125)", "--size": "calc(var(--size-selector, 0.25rem) * 6)", width: "calc((var(--size) * 2) - (var(--border) + var(--toggle-p)) * 2)", height: "var(--size)", "> *": { "z-index": 1, "grid-column": "span 1 / span 1", "grid-column-start": "2", "grid-row-start": "1", height: "100%", cursor: "pointer", appearance: "none", "background-color": "transparent", padding: "calc(0.25rem * 0.5)", transition: "opacity 0.2s, rotate 0.4s", border: "none", "&:focus": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } }, "&:nth-child(2)": { color: "var(--color-base-100)", rotate: "0deg" }, "&:nth-child(3)": { color: "var(--color-base-100)", opacity: "0%", rotate: "-15deg" } }, "&:has(:checked)": { "> :nth-child(2)": { opacity: "0%", rotate: "15deg" }, "> :nth-child(3)": { opacity: "100%", rotate: "0deg" } }, "&:before": { position: "relative", "inset-inline-start": "calc(0.25rem * 0)", "grid-column-start": "2", "grid-row-start": "1", "aspect-ratio": "1 / 1", height: "100%", "border-radius": "var(--radius-selector)", "background-color": "currentColor", translate: "0", "--tw-content": '""', content: "var(--tw-content)", transition: "background-color 0.1s, translate 0.2s, inset-inline-start 0.2s", "box-shadow": "0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000)", "background-size": "auto, calc(var(--noise) * 100%)", "background-image": "none, var(--fx-noise)" }, "@media (forced-colors: active)": { "&:before": { "outline-style": "var(--tw-outline-style)", "outline-width": "1px", "outline-offset": "calc(1px * -1)" } }, "@media print": { "&:before": { outline: "0.25rem solid", "outline-offset": "-1rem" } }, "&:focus-visible, &:has(:focus-visible)": { outline: "2px solid currentColor", "outline-offset": "2px" }, '&:checked, &[aria-checked="true"], &:has(> input:checked)': { "grid-template-columns": "1fr 1fr 0fr", "background-color": "var(--color-base-100)", "--input-color": "var(--color-base-content)", "&:before": { "background-color": "currentColor" }, "@starting-style": { "&:before": { opacity: 0 } } }, "&:indeterminate": { "grid-template-columns": "0.5fr 1fr 0.5fr" }, "&:disabled": { cursor: "not-allowed", opacity: "30%", "&:before": { "background-color": "transparent", border: "var(--border) solid currentColor" } } }, ".toggle-primary": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-primary)" } }, ".toggle-secondary": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-secondary)" } }, ".toggle-accent": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-accent)" } }, ".toggle-neutral": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-neutral)" } }, ".toggle-success": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-success)" } }, ".toggle-warning": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-warning)" } }, ".toggle-info": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-info)" } }, ".toggle-error": { '&:checked, &[aria-checked="true"]': { "--input-color": "var(--color-error)" } }, ".toggle-xs": { '&:is([type="checkbox"]), &:has([type="checkbox"])': { "--size": "calc(var(--size-selector, 0.25rem) * 4)" } }, ".toggle-sm": { '&:is([type="checkbox"]), &:has([type="checkbox"])': { "--size": "calc(var(--size-selector, 0.25rem) * 5)" } }, ".toggle-md": { '&:is([type="checkbox"]), &:has([type="checkbox"])': { "--size": "calc(var(--size-selector, 0.25rem) * 6)" } }, ".toggle-lg": { '&:is([type="checkbox"]), &:has([type="checkbox"])': { "--size": "calc(var(--size-selector, 0.25rem) * 7)" } }, ".toggle-xl": { '&:is([type="checkbox"]), &:has([type="checkbox"])': { "--size": "calc(var(--size-selector, 0.25rem) * 8)" } } }; // packages/daisyui/components/toggle/index.js var toggle_default = ({ addComponents, prefix = "" }) => { const prefixedtoggle = addPrefix(object_default33, prefix); addComponents({ ...prefixedtoggle }); }; // packages/daisyui/components/stack/object.js var object_default34 = { ".stack": { display: "inline-grid", "grid-template-columns": "3px 4px 1fr 4px 3px", "grid-template-rows": "3px 4px 1fr 4px 3px", "& > *": { height: "100%", width: "100%", "&:nth-child(n + 2)": { width: "100%", opacity: "70%" }, "&:nth-child(2)": { "z-index": 2, opacity: "90%" }, "&:nth-child(1)": { "z-index": 3, width: "100%" } }, "&, &.stack-bottom": { "> *": { "grid-column": "3 / 4", "grid-row": "3 / 6", "&:nth-child(2)": { "grid-column": "2 / 5", "grid-row": "2 / 5" }, "&:nth-child(1)": { "grid-column": "1 / 6", "grid-row": "1 / 4" } } }, "&.stack-top": { "> *": { "grid-column": "3 / 4", "grid-row": "1 / 4", "&:nth-child(2)": { "grid-column": "2 / 5", "grid-row": "2 / 5" }, "&:nth-child(1)": { "grid-column": "1 / 6", "grid-row": "3 / 6" } } }, "&.stack-start": { "> *": { "grid-column": "1 / 4", "grid-row": "3 / 4", "&:nth-child(2)": { "grid-column": "2 / 5", "grid-row": "2 / 5" }, "&:nth-child(1)": { "grid-column": "3 / 6", "grid-row": "1 / 6" } } }, "&.stack-end": { "> *": { "grid-column": "3 / 6", "grid-row": "3 / 4", "&:nth-child(2)": { "grid-column": "2 / 5", "grid-row": "2 / 5" }, "&:nth-child(1)": { "grid-column": "1 / 4", "grid-row": "1 / 6" } } } } }; // packages/daisyui/components/stack/index.js var stack_default = ({ addComponents, prefix = "" }) => { const prefixedstack = addPrefix(object_default34, prefix); addComponents({ ...prefixedstack }); }; // packages/daisyui/components/navbar/object.js var object_default35 = { ".navbar": { display: "flex", width: "100%", "align-items": "center", padding: "0.5rem", "min-height": "4rem" }, ".navbar-start": { display: "inline-flex", "align-items": "center", width: "50%", "justify-content": "flex-start" }, ".navbar-center": { display: "inline-flex", "align-items": "center", "flex-shrink": 0 }, ".navbar-end": { display: "inline-flex", "align-items": "center", width: "50%", "justify-content": "flex-end" } }; // packages/daisyui/components/navbar/index.js var navbar_default = ({ addComponents, prefix = "" }) => { const prefixednavbar = addPrefix(object_default35, prefix); addComponents({ ...prefixednavbar }); }; // packages/daisyui/components/label/object.js var object_default36 = { ".label": { display: "inline-flex", "align-items": "center", gap: "calc(0.25rem * 1.5)", "white-space": "nowrap", color: "color-mix(in oklab, currentColor 60%, transparent)", "&:has(input)": { cursor: "pointer" }, "&:is(.input > *, .select > *)": { display: "flex", height: "calc(100% - 0.5rem)", "align-items": "center", "padding-inline": "calc(0.25rem * 3)", "white-space": "nowrap", "font-size": "inherit", "&:first-child": { "margin-inline-start": "calc(0.25rem * -3)", "margin-inline-end": "calc(0.25rem * 3)", "border-inline-end": "var(--border) solid color-mix(in oklab, currentColor 10%, #0000)" }, "&:last-child": { "margin-inline-start": "calc(0.25rem * 3)", "margin-inline-end": "calc(0.25rem * -3)", "border-inline-start": "var(--border) solid color-mix(in oklab, currentColor 10%, #0000)" } } }, ".floating-label": { position: "relative", display: "block", input: { display: "block", "&::placeholder": { transition: "top 0.1s ease-out, translate 0.1s ease-out, scale 0.1s ease-out, opacity 0.1s ease-out" } }, textarea: { "&::placeholder": { transition: "top 0.1s ease-out, translate 0.1s ease-out, scale 0.1s ease-out, opacity 0.1s ease-out" } }, "> span": { position: "absolute", "inset-inline-start": "calc(0.25rem * 3)", "z-index": 1, "background-color": "var(--color-base-100)", "padding-inline": "calc(0.25rem * 1)", opacity: "0%", "font-size": "0.875rem", top: "calc(var(--size-field, 0.25rem) * 10 / 2)", "line-height": 1, "border-radius": "2px", "pointer-events": "none", translate: "0 -50%", transition: "top 0.1s ease-out, translate 0.1s ease-out, scale 0.1s ease-out, opacity 0.1s ease-out" }, "&:focus-within, &:not(:has(input:placeholder-shown, textarea:placeholder-shown))": { "::placeholder": { opacity: "0%", top: "0", translate: "-12.5% calc(-50% - 0.125em)", scale: "0.75", "pointer-events": "auto" }, "> span": { opacity: "100%", top: "0", translate: "-12.5% calc(-50% - 0.125em)", scale: "0.75", "pointer-events": "auto", "z-index": 2 } }, "&:has(:disabled, [disabled])": { "> span": { opacity: "0%" } }, "&:has(.input-xs, .select-xs, .textarea-xs) span": { "font-size": "0.6875rem", top: "calc(var(--size-field, 0.25rem) * 6 / 2)" }, "&:has(.input-sm, .select-sm, .textarea-sm) span": { "font-size": "0.75rem", top: "calc(var(--size-field, 0.25rem) * 8 / 2)" }, "&:has(.input-md, .select-md, .textarea-md) span": { "font-size": "0.875rem", top: "calc(var(--size-field, 0.25rem) * 10 / 2)" }, "&:has(.input-lg, .select-lg, .textarea-lg) span": { "font-size": "1.125rem", top: "calc(var(--size-field, 0.25rem) * 12 / 2)" }, "&:has(.input-xl, .select-xl, .textarea-xl) span": { "font-size": "1.375rem", top: "calc(var(--size-field, 0.25rem) * 14 / 2)" } } }; // packages/daisyui/components/label/index.js var label_default = ({ addComponents, prefix = "" }) => { const prefixedlabel = addPrefix(object_default36, prefix); addComponents({ ...prefixedlabel }); }; // packages/daisyui/components/menu/object.js var object_default37 = { ".menu": { display: "flex", width: "fit-content", "flex-direction": "column", "flex-wrap": "wrap", padding: "calc(0.25rem * 2)", "--menu-active-fg": "var(--color-neutral-content)", "--menu-active-bg": "var(--color-neutral)", "font-size": "0.875rem", ":where(li ul)": { position: "relative", "margin-inline-start": "calc(0.25rem * 4)", "padding-inline-start": "calc(0.25rem * 2)", "white-space": "nowrap", "&:before": { position: "absolute", "inset-inline-start": "calc(0.25rem * 0)", top: "calc(0.25rem * 3)", bottom: "calc(0.25rem * 3)", "background-color": "var(--color-base-content)", opacity: "10%", width: "var(--border)", content: '""' } }, ":where(li > .menu-dropdown:not(.menu-dropdown-show))": { display: "none" }, ":where(li:not(.menu-title) > *:not(ul, details, .menu-title, .btn)), :where(li:not(.menu-title) > details > summary:not(.menu-title))": { display: "grid", "grid-auto-flow": "column", "align-content": "flex-start", "align-items": "center", gap: "calc(0.25rem * 2)", "border-radius": "var(--radius-field)", "padding-inline": "calc(0.25rem * 3)", "padding-block": "calc(0.25rem * 1.5)", "text-align": "start", "transition-property": "color, background-color, box-shadow", "transition-duration": "0.2s", "transition-timing-function": "cubic-bezier(0, 0, 0.2, 1)", "grid-auto-columns": "minmax(auto, max-content) auto max-content", "text-wrap": "balance", "user-select": "none" }, ":where(li > details > summary)": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" }, "&::-webkit-details-marker": { display: "none" } }, ":where(li > details > summary), :where(li > .menu-dropdown-toggle)": { "&:after": { "justify-self": "flex-end", display: "block", height: "0.375rem", width: "0.375rem", rotate: "-135deg", translate: "0 -1px", "transition-property": "rotate, translate", "transition-duration": "0.2s", content: '""', "transform-origin": "50% 50%", "box-shadow": "2px 2px inset", "pointer-events": "none" } }, ":where(li > details[open] > summary):after, :where(li > .menu-dropdown-toggle.menu-dropdown-show):after": { rotate: "45deg", translate: "0 1px" }, ":where( li:not(.menu-title, .disabled) > *:not(ul, details, .menu-title), li:not(.menu-title, .disabled) > details > summary:not(.menu-title) ):not(.menu-active, :active, .btn)": { "&.menu-focus, &:focus-visible": { cursor: "pointer", "background-color": "color-mix(in oklab, var(--color-base-content) 10%, transparent)", color: "var(--color-base-content)", "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } } }, ":where( li:not(.menu-title, .disabled) > *:not(ul, details, .menu-title):not(.menu-active, :active, .btn):hover, li:not(.menu-title, .disabled) > details > summary:not(.menu-title):not(.menu-active, :active, .btn):hover )": { cursor: "pointer", "background-color": "color-mix(in oklab, var(--color-base-content) 10%, transparent)", "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" }, "box-shadow": "0 1px oklch(0% 0 0 / 0.01) inset, 0 -1px oklch(100% 0 0 / 0.01) inset" }, ":where(li:empty)": { "background-color": "var(--color-base-content)", opacity: "10%", margin: "0.5rem 1rem", height: "1px" }, ":where(li)": { position: "relative", display: "flex", "flex-shrink": 0, "flex-direction": "column", "flex-wrap": "wrap", "align-items": "stretch", ".badge": { "justify-self": "flex-end" }, "& > *:not(ul, .menu-title, details, .btn):active, & > *:not(ul, .menu-title, details, .btn).menu-active, & > details > summary:active": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" }, color: "var(--menu-active-fg)", "background-color": "var(--menu-active-bg)", "background-size": "auto, calc(var(--noise) * 100%)", "background-image": "none, var(--fx-noise)", "&:not(&:active)": { "box-shadow": "0 2px calc(var(--depth) * 3px) -2px var(--menu-active-bg)" } }, "&.menu-disabled": { "pointer-events": "none", color: "color-mix(in oklab, var(--color-base-content) 20%, transparent)" } }, ".dropdown:focus-within": { ".menu-dropdown-toggle:after": { rotate: "45deg", translate: "0 1px" } }, ".dropdown-content": { "margin-top": "calc(0.25rem * 2)", padding: "calc(0.25rem * 2)", "&:before": { display: "none" } } }, ".menu-title": { "padding-inline": "calc(0.25rem * 3)", "padding-block": "calc(0.25rem * 2)", color: "color-mix(in oklab, var(--color-base-content) 40%, transparent)", "font-size": "0.875rem", "font-weight": 600 }, ".menu-horizontal": { display: "inline-flex", "flex-direction": "row", "& > li:not(.menu-title) > details > ul": { position: "absolute", "margin-inline-start": "calc(0.25rem * 0)", "margin-top": "calc(0.25rem * 4)", "padding-block": "calc(0.25rem * 2)", "padding-inline-end": "calc(0.25rem * 2)" }, "& > li > details > ul": { "&:before": { content: "none" } }, ":where(& > li:not(.menu-title) > details > ul)": { "border-radius": "var(--radius-box)", "background-color": "var(--color-base-100)", "box-shadow": "0 1px 3px 0 oklch(0% 0 0/0.1), 0 1px 2px -1px oklch(0% 0 0/0.1)" } }, ".menu-vertical": { display: "inline-flex", "flex-direction": "column", "& > li:not(.menu-title) > details > ul": { position: "relative", "margin-inline-start": "calc(0.25rem * 4)", "margin-top": "calc(0.25rem * 0)", "padding-block": "calc(0.25rem * 0)", "padding-inline-end": "calc(0.25rem * 0)" } }, ".menu-xs": { ":where(li:not(.menu-title) > *:not(ul, details, .menu-title)), :where(li:not(.menu-title) > details > summary:not(.menu-title))": { "border-radius": "var(--radius-field)", "padding-inline": "calc(0.25rem * 2)", "padding-block": "calc(0.25rem * 1)", "font-size": "0.6875rem" }, ".menu-title": { "padding-inline": "calc(0.25rem * 2)", "padding-block": "calc(0.25rem * 1)" } }, ".menu-sm": { ":where(li:not(.menu-title) > *:not(ul, details, .menu-title)), :where(li:not(.menu-title) > details > summary:not(.menu-title))": { "border-radius": "var(--radius-field)", "padding-inline": "calc(0.25rem * 2.5)", "padding-block": "calc(0.25rem * 1)", "font-size": "0.75rem" }, ".menu-title": { "padding-inline": "calc(0.25rem * 3)", "padding-block": "calc(0.25rem * 2)" } }, ".menu-md": { ":where(li:not(.menu-title) > *:not(ul, details, .menu-title)), :where(li:not(.menu-title) > details > summary:not(.menu-title))": { "border-radius": "var(--radius-field)", "padding-inline": "calc(0.25rem * 3)", "padding-block": "calc(0.25rem * 1.5)", "font-size": "0.875rem" }, ".menu-title": { "padding-inline": "calc(0.25rem * 3)", "padding-block": "calc(0.25rem * 2)" } }, ".menu-lg": { ":where(li:not(.menu-title) > *:not(ul, details, .menu-title)), :where(li:not(.menu-title) > details > summary:not(.menu-title))": { "border-radius": "var(--radius-field)", "padding-inline": "calc(0.25rem * 4)", "padding-block": "calc(0.25rem * 1.5)", "font-size": "1.125rem" }, ".menu-title": { "padding-inline": "calc(0.25rem * 6)", "padding-block": "calc(0.25rem * 3)" } }, ".menu-xl": { ":where(li:not(.menu-title) > *:not(ul, details, .menu-title)), :where(li:not(.menu-title) > details > summary:not(.menu-title))": { "border-radius": "var(--radius-field)", "padding-inline": "calc(0.25rem * 5)", "padding-block": "calc(0.25rem * 1.5)", "font-size": "1.375rem" }, ".menu-title": { "padding-inline": "calc(0.25rem * 6)", "padding-block": "calc(0.25rem * 3)" } } }; // packages/daisyui/components/menu/index.js var menu_default = ({ addComponents, prefix = "" }) => { const prefixedmenu = addPrefix(object_default37, prefix); addComponents({ ...prefixedmenu }); }; // packages/daisyui/components/toast/object.js var object_default38 = { ".toast": { position: "fixed", "inset-inline-start": "auto", "inset-inline-end": "calc(0.25rem * 4)", top: "auto", bottom: "calc(0.25rem * 4)", display: "flex", "flex-direction": "column", gap: "calc(0.25rem * 2)", "background-color": "transparent", translate: "var(--toast-x, 0) var(--toast-y, 0)", width: "max-content", "max-width": "calc(100vw - 2rem)", "& > *": { animation: "toast 0.25s ease-out" }, "&:where(.toast-start)": { "inset-inline-start": "calc(0.25rem * 4)", "inset-inline-end": "auto", "--toast-x": "0" }, "&:where(.toast-center)": { "inset-inline-start": "calc(1/2 * 100%)", "inset-inline-end": "calc(1/2 * 100%)", "--toast-x": "-50%" }, "&:where(.toast-end)": { "inset-inline-start": "auto", "inset-inline-end": "calc(0.25rem * 4)", "--toast-x": "0" }, "&:where(.toast-bottom)": { top: "auto", bottom: "calc(0.25rem * 4)", "--toast-y": "0" }, "&:where(.toast-middle)": { top: "calc(1/2 * 100%)", bottom: "auto", "--toast-y": "-50%" }, "&:where(.toast-top)": { top: "calc(0.25rem * 4)", bottom: "auto", "--toast-y": "0" } }, "@keyframes toast": { "0%": { scale: "0.9", opacity: 0 }, "100%": { scale: "1", opacity: 1 } } }; // packages/daisyui/components/toast/index.js var toast_default = ({ addComponents, prefix = "" }) => { const prefixedtoast = addPrefix(object_default38, prefix); addComponents({ ...prefixedtoast }); }; // packages/daisyui/components/button/object.js var object_default39 = { ":where(.btn)": { width: "unset" }, ".btn": { display: "inline-flex", "flex-shrink": 0, cursor: "pointer", "flex-wrap": "nowrap", "align-items": "center", "justify-content": "center", gap: "calc(0.25rem * 1.5)", "text-align": "center", "vertical-align": "middle", "outline-offset": "2px", "webkit-user-select": "none", "user-select": "none", "padding-inline": "var(--btn-p)", color: "var(--btn-fg)", "--tw-prose-links": "var(--btn-fg)", height: "var(--size)", "font-size": "var(--fontsize, 0.875rem)", "font-weight": 600, "outline-color": "var(--btn-color, var(--color-base-content))", "transition-property": "color, background-color, border-color, box-shadow", "transition-timing-function": "cubic-bezier(0, 0, 0.2, 1)", "transition-duration": "0.2s", "border-start-start-radius": "var(--join-ss, var(--radius-field))", "border-start-end-radius": "var(--join-se, var(--radius-field))", "border-end-start-radius": "var(--join-es, var(--radius-field))", "border-end-end-radius": "var(--join-ee, var(--radius-field))", "background-color": "var(--btn-bg)", "background-size": "auto, calc(var(--noise) * 100%)", "background-image": "none, var(--btn-noise)", "border-width": "var(--border)", "border-style": "solid", "border-color": "var(--btn-border)", "text-shadow": "0 0.5px oklch(100% 0 0 / calc(var(--depth) * 0.15))", "touch-action": "manipulation", "box-shadow": "0 0.5px 0 0.5px oklch(100% 0 0 / calc(var(--depth) * 6%)) inset, var(--btn-shadow)", "--size": "calc(var(--size-field, 0.25rem) * 10)", "--btn-bg": "var(--btn-color, var(--color-base-200))", "--btn-fg": "var(--color-base-content)", "--btn-p": "1rem", "--btn-border": "color-mix(in oklab, var(--btn-bg), #000 calc(var(--depth) * 5%))", "--btn-shadow": `0 3px 2px -2px color-mix(in oklab, var(--btn-bg) calc(var(--depth) * 30%), #0000), 0 4px 3px -2px color-mix(in oklab, var(--btn-bg) calc(var(--depth) * 30%), #0000)`, "--btn-noise": "var(--fx-noise)", ".prose &": { "text-decoration-line": "none" }, "@media (hover: hover)": { "&:hover": { "--btn-bg": "color-mix(in oklab, var(--btn-color, var(--color-base-200)), #000 7%)" } }, "&:focus-visible": { "outline-width": "2px", "outline-style": "solid", isolation: "isolate" }, "&:active:not(.btn-active)": { translate: "0 0.5px", "--btn-bg": "color-mix(in oklab, var(--btn-color, var(--color-base-200)), #000 5%)", "--btn-border": "color-mix(in oklab, var(--btn-color, var(--color-base-200)), #000 7%)", "--btn-shadow": "0 0 0 0 oklch(0% 0 0/0), 0 0 0 0 oklch(0% 0 0/0)" }, "&:is(:disabled, [disabled], .btn-disabled)": { "&:not(.btn-link, .btn-ghost)": { "background-color": "color-mix(in oklab, var(--color-base-content) 10%, transparent)", "box-shadow": "none" }, "pointer-events": "none", "--btn-border": "#0000", "--btn-noise": "none", "--btn-fg": "color-mix(in oklch, var(--color-base-content) 20%, #0000)", "@media (hover: hover)": { "&:hover": { "pointer-events": "none", "background-color": "color-mix(in oklab, var(--color-neutral) 20%, transparent)", "--btn-border": "#0000", "--btn-fg": "color-mix(in oklch, var(--color-base-content) 20%, #0000)" } } }, '&:is(input[type="checkbox"], input[type="radio"])': { appearance: "none", "&::after": { content: "attr(aria-label)" } }, "&:where(input:checked:not(.filter .btn))": { "--btn-color": "var(--color-primary)", "--btn-fg": "var(--color-primary-content)", isolation: "isolate" } }, ".btn-active": { "--btn-bg": "color-mix(in oklab, var(--btn-color, var(--color-base-200)), #000 7%)", "--btn-shadow": "0 0 0 0 oklch(0% 0 0/0), 0 0 0 0 oklch(0% 0 0/0)", isolation: "isolate" }, ".btn-primary": { "--btn-color": "var(--color-primary)", "--btn-fg": "var(--color-primary-content)" }, ".btn-secondary": { "--btn-color": "var(--color-secondary)", "--btn-fg": "var(--color-secondary-content)" }, ".btn-accent": { "--btn-color": "var(--color-accent)", "--btn-fg": "var(--color-accent-content)" }, ".btn-neutral": { "--btn-color": "var(--color-neutral)", "--btn-fg": "var(--color-neutral-content)" }, ".btn-info": { "--btn-color": "var(--color-info)", "--btn-fg": "var(--color-info-content)" }, ".btn-success": { "--btn-color": "var(--color-success)", "--btn-fg": "var(--color-success-content)" }, ".btn-warning": { "--btn-color": "var(--color-warning)", "--btn-fg": "var(--color-warning-content)" }, ".btn-error": { "--btn-color": "var(--color-error)", "--btn-fg": "var(--color-error-content)" }, ".btn-ghost": { "&:not(.btn-active, :hover, :active:focus, :focus-visible)": { "--btn-shadow": '""', "--btn-bg": "#0000", "--btn-border": "#0000", "--btn-noise": "none", "&:not(:disabled, [disabled], .btn-disabled)": { "outline-color": "currentColor", "--btn-fg": "currentColor" } } }, ".btn-link": { "text-decoration-line": "underline", "outline-color": "currentColor", "--btn-border": "#0000", "--btn-bg": "#0000", "--btn-fg": "var(--color-primary)", "--btn-noise": "none", "--btn-shadow": '""', "&:is(.btn-active, :hover, :active:focus, :focus-visible)": { "text-decoration-line": "underline", "--btn-border": "#0000", "--btn-bg": "#0000" } }, ".btn-outline": { "&:not( .btn-active, :hover, :active:focus, :focus-visible, :disabled, [disabled], .btn-disabled, :checked )": { "--btn-shadow": '""', "--btn-bg": "#0000", "--btn-fg": "var(--btn-color)", "--btn-border": "var(--btn-color)", "--btn-noise": "none" }, "@media (hover: none)": { "&:hover:not( .btn-active, :active, :focus-visible, :disabled, [disabled], .btn-disabled, :checked )": { "--btn-shadow": '""', "--btn-bg": "#0000", "--btn-fg": "var(--btn-color)", "--btn-border": "var(--btn-color)", "--btn-noise": "none" } } }, ".btn-dash": { "&:not( .btn-active, :hover, :active:focus, :focus-visible, :disabled, [disabled], .btn-disabled, :checked )": { "--btn-shadow": '""', "border-style": "dashed", "--btn-bg": "#0000", "--btn-fg": "var(--btn-color)", "--btn-border": "var(--btn-color)", "--btn-noise": "none" }, "@media (hover: none)": { "&:hover:not( .btn-active, :active, :focus-visible, :disabled, [disabled], .btn-disabled, :checked )": { "--btn-shadow": '""', "border-style": "dashed", "--btn-bg": "#0000", "--btn-fg": "var(--btn-color)", "--btn-border": "var(--btn-color)", "--btn-noise": "none" } } }, ".btn-soft": { "&:not(.btn-active, :hover, :active:focus, :focus-visible, :disabled, [disabled], .btn-disabled)": { "--btn-shadow": '""', "--btn-fg": "var(--btn-color, var(--color-base-content))", "--btn-bg": `color-mix( in oklab, var(--btn-color, var(--color-base-content)) 8%, var(--color-base-100) )`, "--btn-border": `color-mix( in oklab, var(--btn-color, var(--color-base-content)) 10%, var(--color-base-100) )`, "--btn-noise": "none" }, "@media (hover: none)": { "&:hover:not(.btn-active, :active, :focus-visible, :disabled, [disabled], .btn-disabled)": { "--btn-shadow": '""', "--btn-fg": "var(--btn-color, var(--color-base-content))", "--btn-bg": `color-mix( in oklab, var(--btn-color, var(--color-base-content)) 8%, var(--color-base-100) )`, "--btn-border": `color-mix( in oklab, var(--btn-color, var(--color-base-content)) 10%, var(--color-base-100) )`, "--btn-noise": "none" } } }, ".btn-xs": { "--fontsize": "0.6875rem", "--btn-p": "0.5rem", "--size": "calc(var(--size-field, 0.25rem) * 6)" }, ".btn-sm": { "--fontsize": "0.75rem", "--btn-p": "0.75rem", "--size": "calc(var(--size-field, 0.25rem) * 8)" }, ".btn-md": { "--fontsize": "0.875rem", "--btn-p": "1rem", "--size": "calc(var(--size-field, 0.25rem) * 10)" }, ".btn-lg": { "--fontsize": "1.125rem", "--btn-p": "1.25rem", "--size": "calc(var(--size-field, 0.25rem) * 12)" }, ".btn-xl": { "--fontsize": "1.375rem", "--btn-p": "1.5rem", "--size": "calc(var(--size-field, 0.25rem) * 14)" }, ".btn-square": { "padding-inline": "calc(0.25rem * 0)", width: "var(--size)", height: "var(--size)" }, ".btn-circle": { "border-radius": "calc(infinity * 1px)", "padding-inline": "calc(0.25rem * 0)", width: "var(--size)", height: "var(--size)" }, ".btn-wide": { width: "100%", "max-width": "calc(0.25rem * 64)" }, ".btn-block": { width: "100%" } }; // packages/daisyui/components/button/index.js var button_default = ({ addComponents, prefix = "" }) => { const prefixedbutton = addPrefix(object_default39, prefix); addComponents({ ...prefixedbutton }); }; // packages/daisyui/components/list/object.js var object_default40 = { ".list": { display: "flex", "flex-direction": "column", "font-size": "0.875rem", ":where(.list-row)": { "--list-grid-cols": "minmax(0, auto) 1fr", position: "relative", display: "grid", "grid-auto-flow": "column", gap: "calc(0.25rem * 4)", "border-radius": "var(--radius-box)", padding: "calc(0.25rem * 4)", "word-break": "break-word", "grid-template-columns": "var(--list-grid-cols)", "&:has(.list-col-grow:nth-child(1))": { "--list-grid-cols": "1fr" }, "&:has(.list-col-grow:nth-child(2))": { "--list-grid-cols": "minmax(0, auto) 1fr" }, "&:has(.list-col-grow:nth-child(3))": { "--list-grid-cols": "minmax(0, auto) minmax(0, auto) 1fr" }, "&:has(.list-col-grow:nth-child(4))": { "--list-grid-cols": "minmax(0, auto) minmax(0, auto) minmax(0, auto) 1fr" }, "&:has(.list-col-grow:nth-child(5))": { "--list-grid-cols": "minmax(0, auto) minmax(0, auto) minmax(0, auto) minmax(0, auto) 1fr" }, "&:has(.list-col-grow:nth-child(6))": { "--list-grid-cols": `minmax(0, auto) minmax(0, auto) minmax(0, auto) minmax(0, auto) minmax(0, auto) 1fr` }, ":not(.list-col-wrap)": { "grid-row-start": "1" } }, "& > :not(:last-child)": { "&.list-row, .list-row": { "&:after": { content: '""', "border-bottom": "var(--border) solid", "inset-inline": "var(--radius-box)", position: "absolute", bottom: "calc(0.25rem * 0)", "border-color": "color-mix(in oklab, var(--color-base-content) 5%, transparent)" } } } }, ".list-col-wrap": { "grid-row-start": "2" } }; // packages/daisyui/components/list/index.js var list_default = ({ addComponents, prefix = "" }) => { const prefixedlist = addPrefix(object_default40, prefix); addComponents({ ...prefixedlist }); }; // packages/daisyui/components/mockup/object.js var object_default41 = { ".mockup-code": { position: "relative", overflow: "hidden", "overflow-x": "auto", "border-radius": "var(--radius-box)", "background-color": "var(--color-neutral)", "padding-block": "calc(0.25rem * 5)", color: "var(--color-neutral-content)", "font-size": "0.875rem", direction: "ltr", "&:before": { content: '""', "margin-bottom": "calc(0.25rem * 4)", display: "block", height: "calc(0.25rem * 3)", width: "calc(0.25rem * 3)", "border-radius": "calc(infinity * 1px)", opacity: "30%", "box-shadow": "1.4em 0, 2.8em 0, 4.2em 0" }, pre: { "padding-right": "calc(0.25rem * 5)", "&:before": { content: '""', "margin-right": "2ch" }, "&[data-prefix]": { "&:before": { content: "attr(data-prefix)", display: "inline-block", width: "calc(0.25rem * 8)", "text-align": "right", opacity: "50%" } } } }, ".mockup-window": { position: "relative", display: "flex", "flex-direction": "column", overflow: "hidden", "overflow-x": "auto", "border-radius": "var(--radius-box)", "padding-top": "calc(0.25rem * 5)", "&:before": { content: '""', "margin-bottom": "calc(0.25rem * 4)", display: "block", "aspect-ratio": "1 / 1", height: "calc(0.25rem * 3)", "flex-shrink": 0, "align-self": "flex-start", "border-radius": "calc(infinity * 1px)", opacity: "30%", "box-shadow": "1.4em 0, 2.8em 0, 4.2em 0" }, '[dir="rtl"] &:before': { "align-self": "flex-end" }, "pre[data-prefix]": { "&:before": { content: "attr(data-prefix)", display: "inline-block", "text-align": "right" } } }, ".mockup-browser": { position: "relative", overflow: "hidden", "overflow-x": "auto", "border-radius": "var(--radius-box)", "pre[data-prefix]": { "&:before": { content: "attr(data-prefix)", display: "inline-block", "text-align": "right" } }, ".mockup-browser-toolbar": { "margin-block": "calc(0.25rem * 3)", display: "inline-flex", width: "100%", "align-items": "center", "padding-right": "1.4em", '&:where(:dir(rtl), [dir="rtl"], [dir="rtl"] *)': { "flex-direction": "row-reverse" }, "&:before": { content: '""', "margin-right": "4.8rem", display: "inline-block", "aspect-ratio": "1 / 1", height: "calc(0.25rem * 3)", "border-radius": "calc(infinity * 1px)", opacity: "30%", "box-shadow": "1.4em 0, 2.8em 0, 4.2em 0" }, ".input": { "margin-inline": "auto", display: "flex", height: "100%", "align-items": "center", gap: "calc(0.25rem * 2)", overflow: "hidden", "background-color": "var(--color-base-200)", "text-overflow": "ellipsis", "white-space": "nowrap", "font-size": "0.75rem", direction: "ltr", "&:before": { content: '""', width: "calc(0.25rem * 4)", height: "calc(0.25rem * 4)", opacity: "30%", "background-image": `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='currentColor' class='size-4'%3E%3Cpath fill-rule='evenodd' d='M9.965 11.026a5 5 0 1 1 1.06-1.06l2.755 2.754a.75.75 0 1 1-1.06 1.06l-2.755-2.754ZM10.5 7a3.5 3.5 0 1 1-7 0 3.5 3.5 0 0 1 7 0Z' clip-rule='evenodd' /%3E%3C/svg%3E%0A")` } } } }, ".mockup-phone": { display: "inline-grid", "justify-items": "center", border: "6px solid #6b6b6b", "border-radius": "65px", "background-color": "#000", padding: "11px", overflow: "hidden" }, ".mockup-phone-camera": { "grid-column": "1/1", "grid-row": "1/1", background: "#000", height: "32px", width: "126px", "border-radius": "17px", "z-index": 1, "margin-top": "6px" }, ".mockup-phone-display": { "grid-column": "1/1", "grid-row": "1/1", overflow: "hidden", "border-radius": "49px", width: "390px", height: "845px" } }; // packages/daisyui/components/mockup/index.js var mockup_default = ({ addComponents, prefix = "" }) => { const prefixedmockup = addPrefix(object_default41, prefix); addComponents({ ...prefixedmockup }); }; // packages/daisyui/components/calendar/object.js var object_default42 = { ".cally": { "font-size": "0.7rem", "&::part(container)": { padding: "0.5rem 1rem", "user-select": "none" }, "::part(th)": { "font-weight": "normal", "block-size": "auto" }, "&::part(header)": { direction: "ltr" }, "::part(head)": { opacity: 0.5, "font-size": "0.7rem" }, "&::part(button)": { "border-radius": "var(--radius-field)", border: "none", padding: "0.5rem", background: "#0000" }, "&::part(button):hover": { background: "var(--color-base-200)" }, "::part(day)": { "border-radius": "var(--radius-field)", "font-size": "0.7rem" }, "::part(button day today)": { background: "var(--color-primary)", color: "var(--color-primary-content)" }, "::part(selected)": { color: "var(--color-base-100)", background: "var(--color-base-content)", "border-radius": "var(--radius-field)" }, "::part(range-inner)": { "border-radius": "0" }, "::part(range-start)": { "border-start-end-radius": "0", "border-end-end-radius": "0" }, "::part(range-end)": { "border-start-start-radius": "0", "border-end-start-radius": "0" }, "::part(range-start range-end)": { "border-radius": "var(--radius-field)" }, "calendar-month": { width: "100%" } }, ".react-day-picker": { "user-select": "none", "background-color": "var(--color-base-100)", "border-radius": "var(--radius-box)", border: "var(--border) solid var(--color-base-200)", "font-size": "0.75rem", display: "inline-block", position: "relative", overflow: "clip", '&[dir="rtl"]': { ".rdp-nav": { ".rdp-chevron": { "transform-origin": "50%", transform: "rotate(180deg)" } } }, "*": { "box-sizing": "border-box" }, ".rdp-day": { width: "2.25rem", height: "2.25rem", "text-align": "center" }, ".rdp-day_button": { cursor: "pointer", font: "inherit", color: "inherit", width: "2.25rem", height: "2.25rem", border: "2px solid #0000", "border-radius": "var(--radius-field)", background: "0 0", "justify-content": "center", "align-items": "center", margin: "0", padding: "0", display: "flex", "&:disabled": { cursor: "revert" }, "&:hover": { "background-color": "var(--color-base-200)" } }, ".rdp-caption_label": { "z-index": 1, "white-space": "nowrap", border: "0", "align-items": "center", display: "inline-flex", position: "relative" }, ".rdp-button_next": { "border-radius": "var(--radius-field)", "&:hover": { "background-color": "var(--color-base-200)" } }, ".rdp-button_previous": { "border-radius": "var(--radius-field)", "&:hover": { "background-color": "var(--color-base-200)" } }, ".rdp-button_next, .rdp-button_previous": { cursor: "pointer", font: "inherit", color: "inherit", appearance: "none", width: "2.25rem", height: "2.25rem", background: "0 0", border: "none", "justify-content": "center", "align-items": "center", margin: "0", padding: "0", display: "inline-flex", position: "relative", "&:disabled": { cursor: "revert", opacity: 0.5 } }, ".rdp-chevron": { fill: "var(--color-base-content)", width: "1rem", height: "1rem", display: "inline-block" }, ".rdp-dropdowns": { "align-items": "center", gap: "0.5rem", display: "inline-flex", position: "relative" }, ".rdp-dropdown": { "z-index": 2, opacity: 0, appearance: "none", cursor: "inherit", "line-height": "inherit", border: "none", width: "100%", margin: "0", padding: "0", position: "absolute", "inset-block": "0", "inset-inline-start": "0", "&:focus-visible": { "~ .rdp-caption_label": { outline: ["5px auto highlight", "5px auto -webkit-focus-ring-color"] } } }, ".rdp-dropdown_root": { "align-items": "center", display: "inline-flex", position: "relative", '&[data-disabled="true"]': { ".rdp-chevron": { opacity: 0.5 } } }, ".rdp-month_caption": { height: "2.75rem", "font-size": "0.75rem", "font-weight": "inherit", "place-content": "center", display: "flex" }, ".rdp-months": { gap: "2rem", "flex-wrap": "wrap", "max-width": "fit-content", padding: "0.5rem", display: "flex", position: "relative" }, ".rdp-month_grid": { "border-collapse": "collapse" }, ".rdp-nav": { height: "2.75rem", "inset-block-start": "0", "inset-inline-end": "0", "justify-content": "space-between", "align-items": "center", width: "100%", "padding-inline": "0.5rem", display: "flex", position: "absolute", top: "0.25rem" }, ".rdp-weekday": { opacity: 0.6, padding: "0.5rem 0rem", "text-align": "center", "font-size": "smaller", "font-weight": 500 }, ".rdp-week_number": { opacity: 0.6, height: "2.25rem", width: "2.25rem", border: "none", "border-radius": "100%", "text-align": "center", "font-size": "small", "font-weight": 400 }, ".rdp-today:not(.rdp-outside)": { ".rdp-day_button": { background: "var(--color-primary)", color: "var(--color-primary-content)" } }, ".rdp-selected": { "font-weight": "inherit", "font-size": "0.75rem", ".rdp-day_button": { color: "var(--color-base-100)", "background-color": "var(--color-base-content)", "border-radius": "var(--radius-field)", border: "none", "&:hover": { "background-color": "var(--color-base-content)" } } }, ".rdp-outside": { opacity: 0.75 }, ".rdp-disabled": { opacity: 0.5 }, ".rdp-hidden": { visibility: "hidden", color: "var(--color-base-content)" }, ".rdp-range_start": { ".rdp-day_button": { "border-radius": "var(--radius-field) 0 0 var(--radius-field)" } }, ".rdp-range_start .rdp-day_button": { "background-color": "var(--color-base-content)", color: "var(--color-base-content)" }, ".rdp-range_middle": { "background-color": "var(--color-base-200)" }, ".rdp-range_middle .rdp-day_button": { border: "unset", "border-radius": "unset", color: "inherit" }, ".rdp-range_end": { color: "var(--color-base-content)", ".rdp-day_button": { "border-radius": "0 var(--radius-field) var(--radius-field) 0" } }, ".rdp-range_end .rdp-day_button": { color: "var(--color-base-content)", "background-color": "var(--color-base-content)" }, ".rdp-range_start.rdp-range_end": { background: "revert" }, ".rdp-focusable": { cursor: "pointer" }, ".rdp-footer": { "border-top": "var(--border) solid var(--color-base-200)", padding: "0.5rem" } }, ".pika-single": { "&:is(div)": { "user-select": "none", "font-size": "0.75rem", "z-index": 999, display: "inline-block", position: "relative", color: "var(--color-base-content)", "background-color": "var(--color-base-100)", "border-radius": "var(--radius-box)", border: "var(--border) solid var(--color-base-200)", padding: "0.5rem", "&:before, &:after": { content: '""', display: "table" }, "&:after": { clear: "both" }, "&.is-hidden": { display: "none" }, "&.is-bound": { position: "absolute" }, ".pika-lendar": { "css-float": "left" }, ".pika-title": { position: "relative", "text-align": "center", select: { cursor: "pointer", position: "absolute", "z-index": 999, margin: "0", left: "0", top: "5px", opacity: 0 } }, ".pika-label": { display: "inline-block", position: "relative", "z-index": 999, overflow: "hidden", margin: "0", padding: "5px 3px", "background-color": "var(--color-base-100)" }, ".pika-prev, .pika-next": { display: "block", cursor: "pointer", position: "absolute", top: "0", outline: "none", border: "0", width: "2.25rem", height: "2.25rem", color: "#0000", "font-size": "1.2em", "border-radius": "var(--radius-field)", "&:hover": { "background-color": "var(--color-base-200)" }, "&.is-disabled": { cursor: "default", opacity: 0.2 }, "&:before": { display: "inline-block", width: "2.25rem", height: "2.25rem", "line-height": 2.25, color: "var(--color-base-content)" } }, ".pika-prev": { left: "0", "&:before": { content: '"‹"' } }, ".pika-next": { right: "0", "&:before": { content: '"›"' } }, ".pika-select": { display: "inline-block" }, ".pika-table": { width: "100%", "border-collapse": "collapse", "border-spacing": "0", border: "0", "th, td": { padding: "0" }, th: { opacity: 0.6, "text-align": "center", width: "2.25rem", height: "2.25rem" } }, ".pika-button": { cursor: "pointer", display: "block", outline: "none", border: "0", margin: "0", width: "2.25rem", height: "2.25rem", padding: "5px", "text-align": ["right", "center"] }, ".pika-week": { color: "var(--color-base-content)" }, ".is-today": { ".pika-button": { background: "var(--color-primary)", color: "var(--color-primary-content)" } }, ".is-selected, .has-event": { ".pika-button": { "&, &:hover": { color: "var(--color-base-100)", "background-color": "var(--color-base-content)", "border-radius": "var(--radius-field)" } } }, ".has-event": { ".pika-button": { background: "var(--color-base-primary)" } }, ".is-disabled, .is-inrange": { ".pika-button": { background: "var(--color-base-primary)" } }, ".is-startrange": { ".pika-button": { color: "var(--color-base-100)", background: "var(--color-base-content)", "border-radius": "var(--radius-field)" } }, ".is-endrange": { ".pika-button": { color: "var(--color-base-100)", background: "var(--color-base-content)", "border-radius": "var(--radius-field)" } }, ".is-disabled": { ".pika-button": { "pointer-events": "none", cursor: "default", color: "var(--color-base-content)", opacity: 0.3 } }, ".is-outside-current-month": { ".pika-button": { color: "var(--color-base-content)", opacity: 0.3 } }, ".is-selection-disabled": { "pointer-events": "none", cursor: "default" }, ".pika-button:hover, .pika-row.pick-whole-week:hover .pika-button": { color: "var(--color-base-content)", "background-color": "var(--color-base-200)", "border-radius": "var(--radius-field)" }, ".pika-table abbr": { "text-decoration": "none", "font-weight": "normal" } } } }; // packages/daisyui/components/calendar/index.js var calendar_default = ({ addComponents, prefix = "" }) => { const prefixedcalendar = addPrefix(object_default42, prefix); addComponents({ ...prefixedcalendar }); }; // packages/daisyui/components/indicator/object.js var object_default43 = { ".indicator": { position: "relative", display: "inline-flex", width: "max-content", ":where(.indicator-item)": { "z-index": 1, position: "absolute", "white-space": "nowrap", top: "var(--inidicator-t, 0)", bottom: "var(--inidicator-b, auto)", left: "var(--inidicator-s, auto)", right: "var(--inidicator-e, 0)", translate: "var(--inidicator-x, 50%) var(--indicator-y, -50%)" } }, ".indicator-start": { "--inidicator-s": "0", "--inidicator-e": "auto", "--inidicator-x": "-50%" }, ".indicator-center": { "--inidicator-s": "50%", "--inidicator-e": "50%", "--inidicator-x": "-50%", '[dir="rtl"] &': { "--inidicator-x": "50%" } }, ".indicator-end": { "--inidicator-s": "auto", "--inidicator-e": "0", "--inidicator-x": "50%" }, ".indicator-bottom": { "--inidicator-t": "auto", "--inidicator-b": "0", "--indicator-y": "50%" }, ".indicator-middle": { "--inidicator-t": "50%", "--inidicator-b": "50%", "--indicator-y": "-50%" }, ".indicator-top": { "--inidicator-t": "0", "--inidicator-b": "auto", "--indicator-y": "-50%" } }; // packages/daisyui/components/indicator/index.js var indicator_default = ({ addComponents, prefix = "" }) => { const prefixedindicator = addPrefix(object_default43, prefix); addComponents({ ...prefixedindicator }); }; // packages/daisyui/components/rating/object.js var object_default44 = { ".rating": { position: "relative", display: "inline-flex", "vertical-align": "middle", "& input": { border: "none", appearance: "none" }, ":where(*)": { animation: "rating 0.25s ease-out", height: "calc(0.25rem * 6)", width: "calc(0.25rem * 6)", "border-radius": "0", "background-color": "var(--color-base-content)", opacity: "20%", "&:is(input)": { cursor: "pointer" } }, "& .rating-hidden": { width: "calc(0.25rem * 2)", "background-color": "transparent" }, 'input[type="radio"]:checked': { "background-image": "none" }, "*": { '&:checked, &[aria-checked="true"], &[aria-current="true"], &:has(~ *:checked, ~ *[aria-checked="true"], ~ *[aria-current="true"])': { opacity: "100%" }, "&:focus-visible": { transition: "scale 0.2s ease-out", scale: "1.1" } }, "& *:active:focus": { animation: "none", scale: "1.1" }, "&.rating-xs :where(*:not(.rating-hidden))": { width: "calc(0.25rem * 4)", height: "calc(0.25rem * 4)" }, "&.rating-sm :where(*:not(.rating-hidden))": { width: "calc(0.25rem * 5)", height: "calc(0.25rem * 5)" }, "&.rating-md :where(*:not(.rating-hidden))": { width: "calc(0.25rem * 6)", height: "calc(0.25rem * 6)" }, "&.rating-lg :where(*:not(.rating-hidden))": { width: "calc(0.25rem * 7)", height: "calc(0.25rem * 7)" }, "&.rating-xl :where(*:not(.rating-hidden))": { width: "calc(0.25rem * 8)", height: "calc(0.25rem * 8)" } }, ".rating-half": { ":where(*:not(.rating-hidden))": { width: "calc(0.25rem * 3)" }, "&.rating-xs *:not(.rating-hidden)": { width: "calc(0.25rem * 2)" }, "&.rating-sm *:not(.rating-hidden)": { width: "calc(0.25rem * 2.5)" }, "&.rating-md *:not(.rating-hidden)": { width: "calc(0.25rem * 3)" }, "&.rating-lg *:not(.rating-hidden)": { width: ".875rem" }, "&.rating-xl *:not(.rating-hidden)": { width: "calc(0.25rem * 4)" } }, "@keyframes rating": { "0%, 40%": { scale: "1.1", filter: "brightness(1.05) contrast(1.05)" } } }; // packages/daisyui/components/rating/index.js var rating_default = ({ addComponents, prefix = "" }) => { const prefixedrating = addPrefix(object_default44, prefix); addComponents({ ...prefixedrating }); }; // packages/daisyui/components/tab/object.js var object_default45 = { ".tabs": { display: "flex", "flex-wrap": "wrap", "--tabs-height": "auto", "--tabs-direction": "row", height: "var(--tabs-height)", "flex-direction": "var(--tabs-direction)" }, ".tab": { position: "relative", display: "inline-flex", cursor: "pointer", appearance: "none", "flex-wrap": "wrap", "align-items": "center", "justify-content": "center", "text-align": "center", "webkit-user-select": "none", "user-select": "none", "&:hover": { "@media (hover: hover)": { color: "var(--color-base-content)" } }, "--tab-p": "1rem", "--tab-bg": "var(--color-base-100)", "--tab-border-color": "var(--color-base-300)", "--tab-radius-ss": "0", "--tab-radius-se": "0", "--tab-radius-es": "0", "--tab-radius-ee": "0", "--tab-order": "0", "--tab-radius-min": "calc(0.75rem - var(--border))", "border-color": "#0000", order: "var(--tab-order)", height: "calc(var(--size-field, 0.25rem) * 10)", "font-size": "0.875rem", "padding-inline-start": "var(--tab-p)", "padding-inline-end": "var(--tab-p)", '&:is(input[type="radio"])': { "min-width": "fit-content", "&:after": { content: "attr(aria-label)" } }, "&:is(label)": { position: "relative", input: { position: "absolute", inset: "calc(0.25rem * 0)", cursor: "pointer", appearance: "none", opacity: "0%" } }, '&:checked, &:is(label:has(:checked)), &:is(.tab-active, [aria-selected="true"])': { "& + .tab-content": { display: "block", height: "100%" } }, '&:not(:checked, label:has(:checked), :hover, .tab-active, [aria-selected="true"])': { color: "color-mix(in oklab, var(--color-base-content) 50%, transparent)" }, "&:not(input):empty": { "flex-grow": 1, cursor: "default" }, "&:focus": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } }, "&:focus-visible, &:is(label:has(:checked:focus-visible))": { outline: "2px solid currentColor", "outline-offset": "-5px" }, "&[disabled]": { "pointer-events": "none", opacity: "40%" } }, ".tab-disabled": { "pointer-events": "none", opacity: "40%" }, ".tabs-border": { ".tab": { "--tab-border-color": "#0000 #0000 var(--tab-border-color) #0000", position: "relative", "border-radius": "var(--radius-field)", "&:before": { "--tw-content": '""', content: "var(--tw-content)", "background-color": "var(--tab-border-color)", transition: "background-color 0.2s ease", width: "80%", height: "3px", "border-radius": "var(--radius-field)", bottom: "0", left: "10%", position: "absolute" }, '&:is(.tab-active, [aria-selected="true"]):not(.tab-disabled, [disabled]), &:is(input:checked), &:is(label:has(:checked))': { "&:before": { "--tab-border-color": "currentColor", "border-top": "3px solid" } } } }, ".tabs-lift": { "--tabs-height": "auto", "--tabs-direction": "row", "> .tab": { "--tab-border": "0 0 var(--border) 0", "--tab-radius-ss": "min(var(--radius-field), var(--tab-radius-min))", "--tab-radius-se": "min(var(--radius-field), var(--tab-radius-min))", "--tab-radius-es": "0", "--tab-radius-ee": "0", "--tab-paddings": "var(--border) var(--tab-p) 0 var(--tab-p)", "--tab-border-colors": "#0000 #0000 var(--tab-border-color) #0000", "--tab-corner-width": "calc(100% + min(var(--radius-field), var(--tab-radius-min)) * 2)", "--tab-corner-height": "min(var(--radius-field), var(--tab-radius-min))", "--tab-corner-position": "top left, top right", "border-width": "var(--tab-border)", "border-start-start-radius": "var(--tab-radius-ss)", "border-start-end-radius": "var(--tab-radius-se)", "border-end-start-radius": "var(--tab-radius-es)", "border-end-end-radius": "var(--tab-radius-ee)", padding: "var(--tab-paddings)", "border-color": "var(--tab-border-colors)", '&:is(.tab-active, [aria-selected="true"]):not(.tab-disabled, [disabled]), &:is(input:checked, label:has(:checked))': { "--tab-border": "var(--border) var(--border) 0 var(--border)", "--tab-border-colors": `var(--tab-border-color) var(--tab-border-color) #0000 var(--tab-border-color)`, "--tab-paddings": `0 calc(var(--tab-p) - var(--border)) var(--border) calc(var(--tab-p) - var(--border))`, "--tab-inset": "auto auto 0 auto", "--tab-grad": "calc(69% - var(--border))", "--radius-start": `radial-gradient( circle at top left, #0000 var(--tab-grad), var(--tab-border-color) calc(var(--tab-grad) + 0.25px), var(--tab-border-color) calc(var(--tab-grad) + var(--border)), var(--tab-bg) calc(var(--tab-grad) + var(--border) + 0.25px) )`, "--radius-end": `radial-gradient( circle at top right, #0000 var(--tab-grad), var(--tab-border-color) calc(var(--tab-grad) + 0.25px), var(--tab-border-color) calc(var(--tab-grad) + var(--border)), var(--tab-bg) calc(var(--tab-grad) + var(--border) + 0.25px) )`, "background-color": "var(--tab-bg)", "&:before": { "z-index": 1, content: '""', display: "block", position: "absolute", width: "var(--tab-corner-width)", height: "var(--tab-corner-height)", "background-position": "var(--tab-corner-position)", "background-image": "var(--radius-start), var(--radius-end)", "background-size": "min(var(--radius-field), var(--tab-radius-min)) min(var(--radius-field), var(--tab-radius-min))", "background-repeat": "no-repeat", inset: "var(--tab-inset)" }, "&:first-child:before": { "--radius-start": "none" }, '[dir="rtl"] &:first-child:before': { transform: "rotateY(180deg)" }, "&:last-child:before": { "--radius-end": "none" }, '[dir="rtl"] &:last-child:before': { transform: "rotateY(180deg)" } } }, "&:has(.tab-content)": { "> .tab:first-child": { '&:not(.tab-active, [aria-selected="true"])': { "--tab-border-colors": `var(--tab-border-color) var(--tab-border-color) #0000 var(--tab-border-color)` } } }, ".tab-content": { "--tabcontent-margin": "calc(-1 * var(--border)) 0 0 0", "--tabcontent-radius-ss": "0", "--tabcontent-radius-se": "var(--radius-box)", "--tabcontent-radius-es": "var(--radius-box)", "--tabcontent-radius-ee": "var(--radius-box)" }, ':checked, label:has(:checked), :is(.tab-active, [aria-selected="true"])': { "& + .tab-content": { "&:nth-child(1), &:nth-child(n + 3)": { "--tabcontent-radius-ss": "var(--radius-box)" } } } }, ".tabs-top": { "--tabs-height": "auto", "--tabs-direction": "row", ".tab": { "--tab-order": "0", "--tab-border": "0 0 var(--border) 0", "--tab-radius-ss": "min(var(--radius-field), var(--tab-radius-min))", "--tab-radius-se": "min(var(--radius-field), var(--tab-radius-min))", "--tab-radius-es": "0", "--tab-radius-ee": "0", "--tab-paddings": "var(--border) var(--tab-p) 0 var(--tab-p)", "--tab-border-colors": "#0000 #0000 var(--tab-border-color) #0000", "--tab-corner-width": "calc(100% + min(var(--radius-field), var(--tab-radius-min)) * 2)", "--tab-corner-height": "min(var(--radius-field), var(--tab-radius-min))", "--tab-corner-position": "top left, top right", '&:is(.tab-active, [aria-selected="true"]):not(.tab-disabled, [disabled]), &:is(input:checked), &:is(label:has(:checked))': { "--tab-border": "var(--border) var(--border) 0 var(--border)", "--tab-border-colors": `var(--tab-border-color) var(--tab-border-color) #0000 var(--tab-border-color)`, "--tab-paddings": `0 calc(var(--tab-p) - var(--border)) var(--border) calc(var(--tab-p) - var(--border))`, "--tab-inset": "auto auto 0 auto", "--radius-start": `radial-gradient( circle at top left, #0000 var(--tab-grad), var(--tab-border-color) calc(var(--tab-grad) + 0.25px), var(--tab-border-color) calc(var(--tab-grad) + var(--border)), var(--tab-bg) calc(var(--tab-grad) + var(--border) + 0.25px) )`, "--radius-end": `radial-gradient( circle at top right, #0000 var(--tab-grad), var(--tab-border-color) calc(var(--tab-grad) + 0.25px), var(--tab-border-color) calc(var(--tab-grad) + var(--border)), var(--tab-bg) calc(var(--tab-grad) + var(--border) + 0.25px) )` } }, "&:has(.tab-content)": { "> .tab:first-child": { '&:not(.tab-active, [aria-selected="true"])': { "--tab-border-colors": `var(--tab-border-color) var(--tab-border-color) #0000 var(--tab-border-color)` } } }, ".tab-content": { "--tabcontent-order": "1", "--tabcontent-margin": "calc(-1 * var(--border)) 0 0 0", "--tabcontent-radius-ss": "0", "--tabcontent-radius-se": "var(--radius-box)", "--tabcontent-radius-es": "var(--radius-box)", "--tabcontent-radius-ee": "var(--radius-box)" }, ':checked, label:has(:checked), :is(.tab-active, [aria-selected="true"])': { "& + .tab-content": { "&:nth-child(1), &:nth-child(n + 3)": { "--tabcontent-radius-ss": "var(--radius-box)" } } } }, ".tabs-bottom": { "--tabs-height": "auto", "--tabs-direction": "row", ".tab": { "--tab-order": "1", "--tab-border": "var(--border) 0 0 0", "--tab-radius-ss": "0", "--tab-radius-se": "0", "--tab-radius-es": "min(var(--radius-field), var(--tab-radius-min))", "--tab-radius-ee": "min(var(--radius-field), var(--tab-radius-min))", "--tab-border-colors": "var(--tab-border-color) #0000 #0000 #0000", "--tab-paddings": "0 var(--tab-p) var(--border) var(--tab-p)", "--tab-corner-width": "calc(100% + min(var(--radius-field), var(--tab-radius-min)) * 2)", "--tab-corner-height": "min(var(--radius-field), var(--tab-radius-min))", "--tab-corner-position": "top left, top right", '&:is(.tab-active, [aria-selected="true"]):not(.tab-disabled, [disabled]), &:is(input:checked), &:is(label:has(:checked))': { "--tab-border": "0 var(--border) var(--border) var(--border)", "--tab-border-colors": `#0000 var(--tab-border-color) var(--tab-border-color) var(--tab-border-color)`, "--tab-paddings": `var(--border) calc(var(--tab-p) - var(--border)) 0 calc(var(--tab-p) - var(--border))`, "--tab-inset": "0 auto auto auto", "--radius-start": `radial-gradient( circle at bottom left, #0000 var(--tab-grad), var(--tab-border-color) calc(var(--tab-grad) + 0.25px), var(--tab-border-color) calc(var(--tab-grad) + var(--border)), var(--tab-bg) calc(var(--tab-grad) + var(--border) + 0.25px) )`, "--radius-end": `radial-gradient( circle at bottom right, #0000 var(--tab-grad), var(--tab-border-color) calc(var(--tab-grad) + 0.25px), var(--tab-border-color) calc(var(--tab-grad) + var(--border)), var(--tab-bg) calc(var(--tab-grad) + var(--border) + 0.25px) )` } }, "&:has(.tab-content)": { "> .tab:first-child": { '&:not(.tab-active, [aria-selected="true"])': { "--tab-border-colors": `#0000 var(--tab-border-color) var(--tab-border-color) var(--tab-border-color)` } } }, ".tab-content": { "--tabcontent-order": "0", "--tabcontent-margin": "0 0 calc(-1 * var(--border)) 0", "--tabcontent-radius-ss": "var(--radius-box)", "--tabcontent-radius-se": "var(--radius-box)", "--tabcontent-radius-es": "0", "--tabcontent-radius-ee": "var(--radius-box)" }, '> :checked, > :is(label:has(:checked)), > :is(.tab-active, [aria-selected="true"])': { "& + .tab-content:not(:nth-child(2))": { "--tabcontent-radius-es": "var(--radius-box)" } } }, ".tabs-box": { "background-color": "var(--color-base-200)", padding: "calc(0.25rem * 1)", "--tabs-box-radius": "calc(var(--radius-field) + var(--radius-field) + var(--radius-field))", "border-radius": "calc(var(--radius-field) + min(0.25rem, var(--tabs-box-radius)))", "box-shadow": "0 -0.5px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 0.5px oklch(0% 0 0 / calc(var(--depth) * 0.05)) inset", ".tab": { "border-radius": "var(--radius-field)", "border-style": "none", "&:focus-visible, &:is(label:has(:checked:focus-visible))": { "outline-offset": "2px" } }, '> :is(.tab-active, [aria-selected="true"]):not(.tab-disabled, [disabled]), > :is(input:checked), > :is(label:has(:checked))': { "background-color": "var(--tab-bg, var(--color-base-100))", "box-shadow": "0 1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px 1px -1px color-mix(in oklab, var(--color-neutral) calc(var(--depth) * 50%), #0000), 0 1px 6px -4px color-mix(in oklab, var(--color-neutral) calc(var(--depth) * 100%), #0000)", "@media (forced-colors: active)": { border: "1px solid" } } }, ".tab-content": { order: [1, "var(--tabcontent-order)"], display: "none", "border-color": "transparent", "--tabcontent-radius-ss": "0", "--tabcontent-radius-se": "0", "--tabcontent-radius-es": "0", "--tabcontent-radius-ee": "0", "--tabcontent-order": "1", width: "100%", margin: "var(--tabcontent-margin)", "border-width": "var(--border)", "border-start-start-radius": "var(--tabcontent-radius-ss)", "border-start-end-radius": "var(--tabcontent-radius-se)", "border-end-start-radius": "var(--tabcontent-radius-es)", "border-end-end-radius": "var(--tabcontent-radius-ee)" }, ".tabs-xs": { ":where(.tab)": { height: "calc(var(--size-field, 0.25rem) * 6)", "font-size": "0.75rem", "--tab-p": "0.375rem", "--tab-radius-min": "calc(0.5rem - var(--border))" } }, ".tabs-sm": { ":where(.tab)": { height: "calc(var(--size-field, 0.25rem) * 8)", "font-size": "0.875rem", "--tab-p": "0.5rem", "--tab-radius-min": "calc(0.5rem - var(--border))" } }, ".tabs-md": { ":where(.tab)": { height: "calc(var(--size-field, 0.25rem) * 10)", "font-size": "0.875rem", "--tab-p": "0.75rem", "--tab-radius-min": "calc(0.75rem - var(--border))" } }, ".tabs-lg": { ":where(.tab)": { height: "calc(var(--size-field, 0.25rem) * 12)", "font-size": "1.125rem", "--tab-p": "1rem", "--tab-radius-min": "calc(1.5rem - var(--border))" } }, ".tabs-xl": { ":where(.tab)": { height: "calc(var(--size-field, 0.25rem) * 14)", "font-size": "1.125rem", "--tab-p": "1.25rem", "--tab-radius-min": "calc(2rem - var(--border))" } } }; // packages/daisyui/components/tab/index.js var tab_default = ({ addComponents, prefix = "" }) => { const prefixedtab = addPrefix(object_default45, prefix); addComponents({ ...prefixedtab }); }; // packages/daisyui/components/filter/object.js var object_default46 = { ".filter": { display: "flex", "flex-wrap": "wrap", 'input[type="radio"]': { width: "auto" }, input: { overflow: "hidden", opacity: "100%", scale: "1", transition: "margin 0.1s, opacity 0.3s, padding 0.3s, border-width 0.1s", "&:not(:last-child)": { "margin-inline-end": "calc(0.25rem * 1)" }, "&.filter-reset": { "aspect-ratio": "1 / 1", "&::after": { content: '"×"' } } }, "&:not(:has(input:checked:not(.filter-reset)))": { '.filter-reset, input[type="reset"]': { scale: "0", "border-width": "0", "margin-inline": "calc(0.25rem * 0)", width: "calc(0.25rem * 0)", "padding-inline": "calc(0.25rem * 0)", opacity: "0%" } }, "&:has(input:checked:not(.filter-reset))": { 'input:not(:checked, .filter-reset, input[type="reset"])': { scale: "0", "border-width": "0", "margin-inline": "calc(0.25rem * 0)", width: "calc(0.25rem * 0)", "padding-inline": "calc(0.25rem * 0)", opacity: "0%" } } } }; // packages/daisyui/components/filter/index.js var filter_default = ({ addComponents, prefix = "" }) => { const prefixedfilter = addPrefix(object_default46, prefix); addComponents({ ...prefixedfilter }); }; // packages/daisyui/components/chat/object.js var object_default47 = { ".chat": { display: "grid", "column-gap": "calc(0.25rem * 3)", "padding-block": "calc(0.25rem * 1)" }, ".chat-bubble": { position: "relative", display: "block", width: "fit-content", "border-radius": "var(--radius-field)", "background-color": "var(--color-base-300)", "padding-inline": "calc(0.25rem * 4)", "padding-block": "calc(0.25rem * 2)", color: "var(--color-base-content)", "grid-row-end": "3", "min-height": "2rem", "min-width": "2.5rem", "max-width": "90%", "&:before": { position: "absolute", bottom: "calc(0.25rem * 0)", height: "calc(0.25rem * 3)", width: "calc(0.25rem * 3)", "background-color": "inherit", content: '""', "mask-repeat": "no-repeat", "mask-image": "var(--mask-chat)", "mask-position": "0px -1px", "mask-size": "13px" } }, ".chat-bubble-primary": { "background-color": "var(--color-primary)", color: "var(--color-primary-content)" }, ".chat-bubble-secondary": { "background-color": "var(--color-secondary)", color: "var(--color-secondary-content)" }, ".chat-bubble-accent": { "background-color": "var(--color-accent)", color: "var(--color-accent-content)" }, ".chat-bubble-neutral": { "background-color": "var(--color-neutral)", color: "var(--color-neutral-content)" }, ".chat-bubble-info": { "background-color": "var(--color-info)", color: "var(--color-info-content)" }, ".chat-bubble-success": { "background-color": "var(--color-success)", color: "var(--color-success-content)" }, ".chat-bubble-warning": { "background-color": "var(--color-warning)", color: "var(--color-warning-content)" }, ".chat-bubble-error": { "background-color": "var(--color-error)", color: "var(--color-error-content)" }, ".chat-image": { "grid-row": "span 2 / span 2", "align-self": "flex-end" }, ".chat-header": { "grid-row-start": "1", display: "flex", gap: "calc(0.25rem * 1)", "font-size": "0.6875rem" }, ".chat-footer": { "grid-row-start": "3", display: "flex", gap: "calc(0.25rem * 1)", "font-size": "0.6875rem" }, ".chat-start": { "place-items": "start", "grid-template-columns": "auto 1fr", ".chat-header": { "grid-column-start": "2" }, ".chat-footer": { "grid-column-start": "2" }, ".chat-image": { "grid-column-start": "1" }, ".chat-bubble": { "grid-column-start": "2", "border-end-start-radius": "0", "&:before": { transform: "rotateY(0deg)", "inset-inline-start": "-0.75rem" }, '[dir="rtl"] &:before': { transform: "rotateY(180deg)" } } }, ".chat-end": { "place-items": "end", "grid-template-columns": "1fr auto", ".chat-header": { "grid-column-start": "1" }, ".chat-footer": { "grid-column-start": "1" }, ".chat-image": { "grid-column-start": "2" }, ".chat-bubble": { "grid-column-start": "1", "border-end-end-radius": "0", "&:before": { transform: "rotateY(180deg)", "inset-inline-start": "100%" }, '[dir="rtl"] &:before': { transform: "rotateY(0deg)" } } } }; // packages/daisyui/components/chat/index.js var chat_default = ({ addComponents, prefix = "" }) => { const prefixedchat = addPrefix(object_default47, prefix); addComponents({ ...prefixedchat }); }; // packages/daisyui/components/radialprogress/object.js var object_default48 = { ".radial-progress": { position: "relative", display: "inline-grid", height: "var(--size)", width: "var(--size)", "place-content": "center", "border-radius": "calc(infinity * 1px)", "background-color": "transparent", "vertical-align": "middle", "box-sizing": "content-box", "--value": "0", "--size": "5rem", "--thickness": "calc(var(--size) / 10)", "--radialprogress": "calc(var(--value) * 1%)", transition: "--radialprogress 0.3s linear", "&:before": { position: "absolute", inset: "calc(0.25rem * 0)", "border-radius": "calc(infinity * 1px)", content: '""', background: "radial-gradient(farthest-side, currentColor 98%, #0000) top/var(--thickness) var(--thickness) no-repeat, conic-gradient(currentColor var(--radialprogress), #0000 0)", "webkit-mask": "radial-gradient( farthest-side, #0000 calc(100% - var(--thickness)), #000 calc(100% + 0.5px - var(--thickness)) )", mask: "radial-gradient( farthest-side, #0000 calc(100% - var(--thickness)), #000 calc(100% + 0.5px - var(--thickness)) )" }, "&:after": { position: "absolute", "border-radius": "calc(infinity * 1px)", "background-color": "currentColor", transition: "transform 0.3s linear", content: '""', inset: "calc(50% - var(--thickness) / 2)", transform: "rotate(calc(var(--value) * 3.6deg - 90deg)) translate(calc(var(--size) / 2 - 50%))" } } }; // packages/daisyui/components/radialprogress/index.js var radialprogress_default = ({ addComponents, prefix = "" }) => { const prefixedradialprogress = addPrefix(object_default48, prefix); addComponents({ ...prefixedradialprogress }); }; // packages/daisyui/components/countdown/object.js var object_default49 = { ".countdown": { display: "inline-flex", "&.countdown": { "line-height": "1em" }, "& > *": { display: "inline-block", "overflow-y": "hidden", height: "1em", "&:before": { position: "relative", content: '"00\\A 01\\A 02\\A 03\\A 04\\A 05\\A 06\\A 07\\A 08\\A 09\\A 10\\A 11\\A 12\\A 13\\A 14\\A 15\\A 16\\A 17\\A 18\\A 19\\A 20\\A 21\\A 22\\A 23\\A 24\\A 25\\A 26\\A 27\\A 28\\A 29\\A 30\\A 31\\A 32\\A 33\\A 34\\A 35\\A 36\\A 37\\A 38\\A 39\\A 40\\A 41\\A 42\\A 43\\A 44\\A 45\\A 46\\A 47\\A 48\\A 49\\A 50\\A 51\\A 52\\A 53\\A 54\\A 55\\A 56\\A 57\\A 58\\A 59\\A 60\\A 61\\A 62\\A 63\\A 64\\A 65\\A 66\\A 67\\A 68\\A 69\\A 70\\A 71\\A 72\\A 73\\A 74\\A 75\\A 76\\A 77\\A 78\\A 79\\A 80\\A 81\\A 82\\A 83\\A 84\\A 85\\A 86\\A 87\\A 88\\A 89\\A 90\\A 91\\A 92\\A 93\\A 94\\A 95\\A 96\\A 97\\A 98\\A 99\\A"', "white-space": "pre", top: "calc(var(--value) * -1em)", "text-align": "center", transition: "all 1s cubic-bezier(1, 0, 0, 1)" } } } }; // packages/daisyui/components/countdown/index.js var countdown_default = ({ addComponents, prefix = "" }) => { const prefixedcountdown = addPrefix(object_default49, prefix); addComponents({ ...prefixedcountdown }); }; // packages/daisyui/components/tooltip/object.js var object_default50 = { ".tooltip": { position: "relative", display: "inline-block", "--tt-bg": "var(--color-neutral)", "--tt-off": "calc(100% + 0.5rem)", "--tt-tail": "calc(100% + 1px + 0.25rem)", "> :where(.tooltip-content), &:where([data-tip]):before": { position: "absolute", "max-width": "20rem", "border-radius": "var(--radius-field)", "padding-inline": "calc(0.25rem * 2)", "padding-block": "calc(0.25rem * 1)", "text-align": "center", "white-space": "normal", color: "var(--color-neutral-content)", opacity: "0%", "font-size": "0.875rem", "line-height": 1.25, transition: "opacity 0.2s cubic-bezier(0.4, 0, 0.2, 1) 75ms, transform 0.2s cubic-bezier(0.4, 0, 0.2, 1) 75ms", "background-color": "var(--tt-bg)", width: "max-content", "pointer-events": "none", "z-index": 1, "--tw-content": "attr(data-tip)", content: "var(--tw-content)" }, "&:after": { position: ["absolute", "absolute"], opacity: "0%", "background-color": "var(--tt-bg)", transition: "opacity 0.2s cubic-bezier(0.4, 0, 0.2, 1) 75ms, transform 0.2s cubic-bezier(0.4, 0, 0.2, 1) 75ms", content: '""', "pointer-events": "none", width: "0.625rem", height: "0.25rem", display: "block", "mask-repeat": "no-repeat", "mask-position": "-1px 0", "--mask-tooltip": `url("data:image/svg+xml,%3Csvg width='10' height='4' viewBox='0 0 8 4' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M0.500009 1C3.5 1 3.00001 4 5.00001 4C7 4 6.5 1 9.5 1C10 1 10 0.499897 10 0H0C-1.99338e-08 0.5 0 1 0.500009 1Z' fill='black'/%3E%3C/svg%3E%0A")`, "mask-image": "var(--mask-tooltip)" }, '&.tooltip-open, &[data-tip]:not([data-tip=""]):hover, &:not(:has(.tooltip-content:empty)):has(.tooltip-content):hover, &:has(:focus-visible)': { "> .tooltip-content, &[data-tip]:before, &:after": { opacity: "100%", "--tt-pos": "0rem", transition: "opacity 0.2s cubic-bezier(0.4, 0, 0.2, 1) 0s, transform 0.2s cubic-bezier(0.4, 0, 0.2, 1) 0ms" } } }, ".tooltip, .tooltip-top": { "> .tooltip-content, &[data-tip]:before": { transform: "translateX(-50%) translateY(var(--tt-pos, 0.25rem))", inset: "auto auto var(--tt-off) 50%" }, "&:after": { transform: "translateX(-50%) translateY(var(--tt-pos, 0.25rem))", inset: "auto auto var(--tt-tail) 50%" } }, ".tooltip-bottom": { "> .tooltip-content, &[data-tip]:before": { transform: "translateX(-50%) translateY(var(--tt-pos, -0.25rem))", inset: "var(--tt-off) auto auto 50%" }, "&:after": { transform: "translateX(-50%) translateY(var(--tt-pos, -0.25rem)) rotate(180deg)", inset: "var(--tt-tail) auto auto 50%" } }, ".tooltip-left": { "> .tooltip-content, &[data-tip]:before": { transform: "translateX(calc(var(--tt-pos, 0.25rem) - 0.25rem)) translateY(-50%)", inset: "50% var(--tt-off) auto auto" }, "&:after": { transform: "translateX(var(--tt-pos, 0.25rem)) translateY(-50%) rotate(-90deg)", inset: "50% calc(var(--tt-tail) + 1px) auto auto" } }, ".tooltip-right": { "> .tooltip-content, &[data-tip]:before": { transform: "translateX(calc(var(--tt-pos, -0.25rem) + 0.25rem)) translateY(-50%)", inset: "50% auto auto var(--tt-off)" }, "&:after": { transform: "translateX(var(--tt-pos, -0.25rem)) translateY(-50%) rotate(90deg)", inset: "50% auto auto calc(var(--tt-tail) + 1px)" } }, ".tooltip-primary": { "--tt-bg": "var(--color-primary)", "> .tooltip-content, &[data-tip]:before": { color: "var(--color-primary-content)" } }, ".tooltip-secondary": { "--tt-bg": "var(--color-secondary)", "> .tooltip-content, &[data-tip]:before": { color: "var(--color-secondary-content)" } }, ".tooltip-accent": { "--tt-bg": "var(--color-accent)", "> .tooltip-content, &[data-tip]:before": { color: "var(--color-accent-content)" } }, ".tooltip-info": { "--tt-bg": "var(--color-info)", "> .tooltip-content, &[data-tip]:before": { color: "var(--color-info-content)" } }, ".tooltip-success": { "--tt-bg": "var(--color-success)", "> .tooltip-content, &[data-tip]:before": { color: "var(--color-success-content)" } }, ".tooltip-warning": { "--tt-bg": "var(--color-warning)", "> .tooltip-content, &[data-tip]:before": { color: "var(--color-warning-content)" } }, ".tooltip-error": { "--tt-bg": "var(--color-error)", "> .tooltip-content, &[data-tip]:before": { color: "var(--color-error-content)" } } }; // packages/daisyui/components/tooltip/index.js var tooltip_default = ({ addComponents, prefix = "" }) => { const prefixedtooltip = addPrefix(object_default50, prefix); addComponents({ ...prefixedtooltip }); }; // packages/daisyui/components/timeline/object.js var object_default51 = { ".timeline": { position: "relative", display: "flex", "> li": { position: "relative", display: "grid", "flex-shrink": 0, "align-items": "center", "grid-template-rows": "var(--timeline-row-start, minmax(0, 1fr)) auto var( --timeline-row-end, minmax(0, 1fr) )", "grid-template-columns": "var(--timeline-col-start, minmax(0, 1fr)) auto var( --timeline-col-end, minmax(0, 1fr) )", "> hr": { border: "none", width: "100%", "&:first-child": { "grid-column-start": "1", "grid-row-start": "2" }, "&:last-child": { "grid-column-start": "3", "grid-column-end": "none", "grid-row-start": "2", "grid-row-end": "auto" }, "@media print": { border: "0.1px solid var(--color-base-300)" } } }, ":where(hr)": { height: "calc(0.25rem * 1)", "background-color": "var(--color-base-300)" }, "&:has(.timeline-middle hr)": { "&:first-child": { "border-start-start-radius": "0", "border-end-start-radius": "0", "border-start-end-radius": "var(--radius-selector)", "border-end-end-radius": "var(--radius-selector)" }, "&:last-child": { "border-start-start-radius": "var(--radius-selector)", "border-end-start-radius": "var(--radius-selector)", "border-start-end-radius": "0", "border-end-end-radius": "0" } }, "&:not(:has(.timeline-middle))": { ":first-child hr:last-child": { "border-start-start-radius": "var(--radius-selector)", "border-end-start-radius": "var(--radius-selector)", "border-start-end-radius": "0", "border-end-end-radius": "0" }, ":last-child hr:first-child": { "border-start-start-radius": "0", "border-end-start-radius": "0", "border-start-end-radius": "var(--radius-selector)", "border-end-end-radius": "var(--radius-selector)" } } }, ".timeline-box": { border: "var(--border) solid", "border-radius": "var(--radius-box)", "border-color": "var(--color-base-300)", "background-color": "var(--color-base-100)", "padding-inline": "calc(0.25rem * 4)", "padding-block": "calc(0.25rem * 2)", "font-size": "0.75rem", "box-shadow": "0 1px 2px 0 oklch(0% 0 0/0.05)" }, ".timeline-start": { "grid-column-start": "1", "grid-column-end": "4", "grid-row-start": "1", "grid-row-end": "2", margin: "calc(0.25rem * 1)", "align-self": "flex-end", "justify-self": "center" }, ".timeline-middle": { "grid-column-start": "2", "grid-row-start": "2" }, ".timeline-end": { "grid-column-start": "1", "grid-column-end": "4", "grid-row-start": "3", "grid-row-end": "4", margin: "calc(0.25rem * 1)", "align-self": "flex-start", "justify-self": "center" }, ".timeline-compact": { "--timeline-row-start": "0", ".timeline-start": { "grid-column-start": "1", "grid-column-end": "4", "grid-row-start": "3", "grid-row-end": "4", "align-self": "flex-start", "justify-self": "center" }, "li:has(.timeline-start)": { ".timeline-end": { "grid-column-start": "none", "grid-row-start": "auto" } }, "&.timeline-vertical": { "> li": { "--timeline-col-start": "0" }, ".timeline-start": { "grid-column-start": "3", "grid-column-end": "4", "grid-row-start": "1", "grid-row-end": "4", "align-self": "center", "justify-self": "flex-start" }, "li:has(.timeline-start)": { ".timeline-end": { "grid-column-start": "auto", "grid-row-start": "none" } } } }, ".timeline-snap-icon": { "> li": { "--timeline-col-start": "0.5rem", "--timeline-row-start": "minmax(0, 1fr)" } }, ".timeline-vertical": { "flex-direction": "column", "> li": { "justify-items": "center", "--timeline-row-start": "minmax(0, 1fr)", "--timeline-row-end": "minmax(0, 1fr)", "> hr": { height: "100%", width: "calc(0.25rem * 1)", "&:first-child": { "grid-column-start": "2", "grid-row-start": "1" }, "&:last-child": { "grid-column-start": "2", "grid-column-end": "auto", "grid-row-start": "3", "grid-row-end": "none" } } }, ".timeline-start": { "grid-column-start": "1", "grid-column-end": "2", "grid-row-start": "1", "grid-row-end": "4", "align-self": "center", "justify-self": "flex-end" }, ".timeline-end": { "grid-column-start": "3", "grid-column-end": "4", "grid-row-start": "1", "grid-row-end": "4", "align-self": "center", "justify-self": "flex-start" }, "&:has(.timeline-middle)": { "> li": { "> hr": { "&:first-child": { "border-top-left-radius": "0", "border-top-right-radius": "0", "border-bottom-right-radius": "var(--radius-selector)", "border-bottom-left-radius": "var(--radius-selector)" }, "&:last-child": { "border-top-left-radius": "var(--radius-selector)", "border-top-right-radius": "var(--radius-selector)", "border-bottom-right-radius": "0", "border-bottom-left-radius": "0" } } } }, "&:not(:has(.timeline-middle))": { ":first-child": { "> hr:last-child": { "border-top-left-radius": "var(--radius-selector)", "border-top-right-radius": "var(--radius-selector)", "border-bottom-right-radius": "0", "border-bottom-left-radius": "0" } }, ":last-child": { "> hr:first-child": { "border-top-left-radius": "0", "border-top-right-radius": "0", "border-bottom-right-radius": "var(--radius-selector)", "border-bottom-left-radius": "var(--radius-selector)" } } }, "&.timeline-snap-icon": { "> li": { "--timeline-col-start": "minmax(0, 1fr)", "--timeline-row-start": "0.5rem" } } }, ".timeline-horizontal": { "flex-direction": "row", "> li": { "align-items": "center", "> hr": { height: "calc(0.25rem * 1)", width: "100%", "&:first-child": { "grid-column-start": "1", "grid-row-start": "2" }, "&:last-child": { "grid-column-start": "3", "grid-column-end": "none", "grid-row-start": "2", "grid-row-end": "auto" } } }, ".timeline-start": { "grid-column-start": "1", "grid-column-end": "4", "grid-row-start": "1", "grid-row-end": "2", "align-self": "flex-end", "justify-self": "center" }, ".timeline-end": { "grid-column-start": "1", "grid-column-end": "4", "grid-row-start": "3", "grid-row-end": "4", "align-self": "flex-start", "justify-self": "center" }, "&:has(.timeline-middle)": { "> li": { "> hr": { "&:first-child": { "border-start-start-radius": "0", "border-end-start-radius": "0", "border-start-end-radius": "var(--radius-selector)", "border-end-end-radius": "var(--radius-selector)" }, "&:last-child": { "border-start-start-radius": "var(--radius-selector)", "border-end-start-radius": "var(--radius-selector)", "border-start-end-radius": "0", "border-end-end-radius": "0" } } } }, "&:not(:has(.timeline-middle))": { ":first-child": { "> hr:last-child": { "border-start-start-radius": "var(--radius-selector)", "border-end-start-radius": "var(--radius-selector)", "border-start-end-radius": "0", "border-end-end-radius": "0" } }, ":last-child": { "> hr:first-child": { "border-start-start-radius": "0", "border-end-start-radius": "0", "border-start-end-radius": "var(--radius-selector)", "border-end-end-radius": "var(--radius-selector)" } } } } }; // packages/daisyui/components/timeline/index.js var timeline_default = ({ addComponents, prefix = "" }) => { const prefixedtimeline = addPrefix(object_default51, prefix); addComponents({ ...prefixedtimeline }); }; // packages/daisyui/components/textarea/object.js var object_default52 = { ".textarea": { border: "var(--border) solid #0000", "min-height": "calc(0.25rem * 20)", "flex-shrink": 1, appearance: "none", "border-radius": "var(--radius-field)", "background-color": "var(--color-base-100)", "padding-block": "calc(0.25rem * 2)", "vertical-align": "middle", width: "clamp(3rem, 20rem, 100%)", "padding-inline-start": "0.75rem", "padding-inline-end": "0.75rem", "font-size": "0.875rem", "border-color": "var(--input-color)", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000) inset, 0 -1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset", "--input-color": "color-mix(in oklab, var(--color-base-content) 20%, #0000)", textarea: { appearance: "none", "background-color": "transparent", border: "none", "&:focus, &:focus-within": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } } }, "&:focus, &:focus-within": { "--input-color": "var(--color-base-content)", "box-shadow": "0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000)", outline: "2px solid var(--input-color)", "outline-offset": "2px", isolation: "isolate" }, "&:has(> textarea[disabled]), &:is(:disabled, [disabled])": { cursor: "not-allowed", "border-color": "var(--color-base-200)", "background-color": "var(--color-base-200)", color: "color-mix(in oklab, var(--color-base-content) 40%, transparent)", "&::placeholder": { color: "color-mix(in oklab, var(--color-base-content) 20%, transparent)" }, "box-shadow": "none" }, "&:has(> textarea[disabled]) > textarea[disabled]": { cursor: "not-allowed" } }, ".textarea-ghost": { "background-color": "transparent", "box-shadow": "none", "border-color": "#0000", "&:focus, &:focus-within": { "background-color": "var(--color-base-100)", color: "var(--color-base-content)", "border-color": "#0000", "box-shadow": "none" } }, ".textarea-neutral": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-neutral)" } }, ".textarea-primary": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-primary)" } }, ".textarea-secondary": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-secondary)" } }, ".textarea-accent": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-accent)" } }, ".textarea-info": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-info)" } }, ".textarea-success": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-success)" } }, ".textarea-warning": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-warning)" } }, ".textarea-error": { "&, &:focus, &:focus-within": { "--input-color": "var(--color-error)" } }, ".textarea-xs": { "font-size": "0.6875rem" }, ".textarea-sm": { "font-size": "0.75rem" }, ".textarea-md": { "font-size": "0.875rem" }, ".textarea-lg": { "font-size": "1.125rem" }, ".textarea-xl": { "font-size": "1.375rem" } }; // packages/daisyui/components/textarea/index.js var textarea_default = ({ addComponents, prefix = "" }) => { const prefixedtextarea = addPrefix(object_default52, prefix); addComponents({ ...prefixedtextarea }); }; // packages/daisyui/components/range/object.js var object_default53 = { ".range": { appearance: "none", "webkit-appearance": "none", "--range-thumb": "var(--color-base-100)", "--range-thumb-size": "calc(var(--size-selector, 0.25rem) * 6)", "--range-progress": "currentColor", "--range-fill": "1", "--range-p": "0.25rem", "--range-bg": "color-mix(in oklab, currentColor 10%, #0000)", cursor: "pointer", overflow: "hidden", "background-color": "transparent", "vertical-align": "middle", width: "clamp(3rem, 20rem, 100%)", "--radius-selector-max": `calc( var(--radius-selector) + var(--radius-selector) + var(--radius-selector) )`, "border-radius": "calc(var(--radius-selector) + min(var(--range-p), var(--radius-selector-max)))", border: "none", height: "var(--range-thumb-size)", '[dir="rtl"] &': { "--range-dir": "-1" }, "&:focus": { outline: "none" }, "&:focus-visible": { outline: "2px solid", "outline-offset": "2px" }, "&::-webkit-slider-runnable-track": { width: "100%", "background-color": "var(--range-bg)", "border-radius": "var(--radius-selector)", height: "calc(var(--range-thumb-size) * 0.5)" }, "@media (forced-colors: active)": [{ "&::-webkit-slider-runnable-track": { border: "1px solid" } }, { "&::-moz-range-track": { border: "1px solid" } }], "&::-webkit-slider-thumb": { position: "relative", "box-sizing": "border-box", "border-radius": "calc(var(--radius-selector) + min(var(--range-p), var(--radius-selector-max)))", "background-color": "currentColor", height: "var(--range-thumb-size)", width: "var(--range-thumb-size)", border: "var(--range-p) solid", appearance: "none", "webkit-appearance": "none", top: "50%", color: "var(--range-progress)", transform: "translateY(-50%)", "box-shadow": "0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000), 0 0 0 2rem var(--range-thumb) inset, calc((var(--range-dir, 1) * -100rem) - (var(--range-dir, 1) * var(--range-thumb-size) / 2)) 0 0 calc(100rem * var(--range-fill))" }, "&::-moz-range-track": { width: "100%", "background-color": "var(--range-bg)", "border-radius": "var(--radius-selector)", height: "calc(var(--range-thumb-size) * 0.5)" }, "&::-moz-range-thumb": { position: "relative", "box-sizing": "border-box", "border-radius": "calc(var(--radius-selector) + min(var(--range-p), var(--radius-selector-max)))", "background-color": "currentColor", height: "var(--range-thumb-size)", width: "var(--range-thumb-size)", border: "var(--range-p) solid", top: "50%", color: "var(--range-progress)", "box-shadow": "0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000), 0 0 0 2rem var(--range-thumb) inset, calc((var(--range-dir, 1) * -100rem) - (var(--range-dir, 1) * var(--range-thumb-size) / 2)) 0 0 calc(100rem * var(--range-fill))" }, "&:disabled": { cursor: "not-allowed", opacity: "30%" } }, ".range-primary": { color: "var(--color-primary)", "--range-thumb": "var(--color-primary-content)" }, ".range-secondary": { color: "var(--color-secondary)", "--range-thumb": "var(--color-secondary-content)" }, ".range-accent": { color: "var(--color-accent)", "--range-thumb": "var(--color-accent-content)" }, ".range-neutral": { color: "var(--color-neutral)", "--range-thumb": "var(--color-neutral-content)" }, ".range-success": { color: "var(--color-success)", "--range-thumb": "var(--color-success-content)" }, ".range-warning": { color: "var(--color-warning)", "--range-thumb": "var(--color-warning-content)" }, ".range-info": { color: "var(--color-info)", "--range-thumb": "var(--color-info-content)" }, ".range-error": { color: "var(--color-error)", "--range-thumb": "var(--color-error-content)" }, ".range-xs": { "--range-thumb-size": "calc(var(--size-selector, 0.25rem) * 4)" }, ".range-sm": { "--range-thumb-size": "calc(var(--size-selector, 0.25rem) * 5)" }, ".range-md": { "--range-thumb-size": "calc(var(--size-selector, 0.25rem) * 6)" }, ".range-lg": { "--range-thumb-size": "calc(var(--size-selector, 0.25rem) * 7)" }, ".range-xl": { "--range-thumb-size": "calc(var(--size-selector, 0.25rem) * 8)" } }; // packages/daisyui/components/range/index.js var range_default = ({ addComponents, prefix = "" }) => { const prefixedrange = addPrefix(object_default53, prefix); addComponents({ ...prefixedrange }); }; // packages/daisyui/components/dock/object.js var object_default54 = { ".dock": { position: "fixed", right: "calc(0.25rem * 0)", bottom: "calc(0.25rem * 0)", left: "calc(0.25rem * 0)", "z-index": 1, display: "flex", width: "100%", "flex-direction": "row", "align-items": "center", "justify-content": "space-around", "background-color": "var(--color-base-100)", padding: "calc(0.25rem * 2)", color: "currentColor", "border-top": "0.5px solid color-mix(in oklab, var(--color-base-content) 5%, #0000)", height: ["4rem", "calc(4rem + env(safe-area-inset-bottom))"], "padding-bottom": "env(safe-area-inset-bottom)", "> *": { position: "relative", "margin-bottom": "calc(0.25rem * 2)", display: "flex", height: "100%", "max-width": "calc(0.25rem * 32)", "flex-shrink": 1, "flex-basis": "100%", cursor: "pointer", "flex-direction": "column", "align-items": "center", "justify-content": "center", gap: "1px", "border-radius": "var(--radius-box)", "background-color": "transparent", transition: "opacity 0.2s ease-out", "@media (hover: hover)": { "&:hover": { opacity: "80%" } }, '&[aria-disabled="true"], &[disabled]': { "&, &:hover": { "pointer-events": "none", color: "color-mix(in oklab, var(--color-base-content) 10%, transparent)", opacity: "100%" } }, ".dock-label": { "font-size": "0.6875rem" }, "&:after": { content: '""', position: "absolute", height: "calc(0.25rem * 1)", width: "calc(0.25rem * 6)", "border-radius": "calc(infinity * 1px)", "background-color": "transparent", bottom: "0.2rem", "border-top": "3px solid transparent", transition: "background-color 0.1s ease-out, text-color 0.1s ease-out, width 0.1s ease-out" } } }, ".dock-active": { "&:after": { width: "calc(0.25rem * 10)", "background-color": "currentColor", color: "currentColor" } }, ".dock-xs": { height: ["3rem", "calc(3rem + env(safe-area-inset-bottom))"], ".dock-active": { "&:after": { bottom: "-0.1rem" } }, ".dock-label": { "font-size": "0.625rem" } }, ".dock-sm": { height: ["calc(0.25rem * 14)", "3.5rem", "calc(3.5rem + env(safe-area-inset-bottom))"], ".dock-active": { "&:after": { bottom: "-0.1rem" } }, ".dock-label": { "font-size": "0.625rem" } }, ".dock-md": { height: ["4rem", "calc(4rem + env(safe-area-inset-bottom))"], ".dock-label": { "font-size": "0.6875rem" } }, ".dock-lg": { height: ["4.5rem", "calc(4.5rem + env(safe-area-inset-bottom))"], ".dock-active": { "&:after": { bottom: "0.4rem" } }, ".dock-label": { "font-size": "0.6875rem" } }, ".dock-xl": { height: ["5rem", "calc(5rem + env(safe-area-inset-bottom))"], ".dock-active": { "&:after": { bottom: "0.4rem" } }, ".dock-label": { "font-size": "0.75rem" } } }; // packages/daisyui/components/dock/index.js var dock_default = ({ addComponents, prefix = "" }) => { const prefixeddock = addPrefix(object_default54, prefix); addComponents({ ...prefixeddock }); }; // packages/daisyui/components/breadcrumbs/object.js var object_default55 = { ".breadcrumbs": { "max-width": "100%", "overflow-x": "auto", "padding-block": "calc(0.25rem * 2)", "> menu, > ul, > ol": { display: "flex", "min-height": "min-content", "align-items": "center", "white-space": "nowrap", "> li": { display: "flex", "align-items": "center", "> *": { display: "flex", cursor: "pointer", "align-items": "center", gap: "calc(0.25rem * 2)", "&:hover": { "@media (hover: hover)": { "text-decoration-line": "underline" } }, "&:focus": { "--tw-outline-style": "none", "outline-style": "none", "@media (forced-colors: active)": { outline: "2px solid transparent", "outline-offset": "2px" } }, "&:focus-visible": { outline: "2px solid currentColor", "outline-offset": "2px" } }, "& + *:before": { content: '""', "margin-right": "calc(0.25rem * 3)", "margin-left": "calc(0.25rem * 2)", display: "block", height: "calc(0.25rem * 1.5)", width: "calc(0.25rem * 1.5)", opacity: "40%", rotate: "45deg", "border-top": "1px solid", "border-right": "1px solid", "background-color": "#0000" }, '[dir="rtl"] & + *:before': { rotate: "-135deg" } } } } }; // packages/daisyui/components/breadcrumbs/index.js var breadcrumbs_default = ({ addComponents, prefix = "" }) => { const prefixedbreadcrumbs = addPrefix(object_default55, prefix); addComponents({ ...prefixedbreadcrumbs }); }; // packages/daisyui/components/radio/object.js var object_default56 = { ".radio": { position: "relative", "flex-shrink": 0, cursor: "pointer", appearance: "none", "border-radius": "calc(infinity * 1px)", padding: "calc(0.25rem * 1)", "vertical-align": "middle", border: "var(--border) solid var(--input-color, color-mix(in srgb, currentColor 20%, #0000))", "box-shadow": "0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset", "--size": "calc(var(--size-selector, 0.25rem) * 6)", width: "var(--size)", height: "var(--size)", color: "var(--input-color, currentColor)", "&:before": { display: "block", width: "100%", height: "100%", "border-radius": "calc(infinity * 1px)", "--tw-content": '""', content: "var(--tw-content)", "background-size": "auto, calc(var(--noise) * 100%)", "background-image": "none, var(--fx-noise)" }, "&:focus-visible": { outline: "2px solid currentColor" }, '&:checked, &[aria-checked="true"]': { animation: "radio 0.2s ease-out", "border-color": "currentColor", "background-color": "var(--color-base-100)", "&:before": { "background-color": "currentColor", "box-shadow": "0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1))" }, "@media (forced-colors: active)": { "&:before": { "outline-style": "var(--tw-outline-style)", "outline-width": "1px", "outline-offset": "calc(1px * -1)" } }, "@media print": { "&:before": { outline: "0.25rem solid", "outline-offset": "-1rem" } } } }, ".radio-primary": { "--input-color": "var(--color-primary)" }, ".radio-secondary": { "--input-color": "var(--color-secondary)" }, ".radio-accent": { "--input-color": "var(--color-accent)" }, ".radio-neutral": { "--input-color": "var(--color-neutral)" }, ".radio-info": { "--input-color": "var(--color-info)" }, ".radio-success": { "--input-color": "var(--color-success)" }, ".radio-warning": { "--input-color": "var(--color-warning)" }, ".radio-error": { "--input-color": "var(--color-error)" }, ".radio:disabled": { cursor: "not-allowed", opacity: "20%" }, ".radio-xs": { padding: "0.125rem", '&:is([type="radio"])': { "--size": "calc(var(--size-selector, 0.25rem) * 4)" } }, ".radio-sm": { padding: "0.1875rem", '&:is([type="radio"])': { "--size": "calc(var(--size-selector, 0.25rem) * 5)" } }, ".radio-md": { padding: "0.25rem", '&:is([type="radio"])': { "--size": "calc(var(--size-selector, 0.25rem) * 6)" } }, ".radio-lg": { padding: "0.3125rem", '&:is([type="radio"])': { "--size": "calc(var(--size-selector, 0.25rem) * 7)" } }, ".radio-xl": { padding: "0.375rem", '&:is([type="radio"])': { "--size": "calc(var(--size-selector, 0.25rem) * 8)" } }, "@keyframes radio": { "0%": { padding: "5px" }, "50%": { padding: "3px" } } }; // packages/daisyui/components/radio/index.js var radio_default = ({ addComponents, prefix = "" }) => { const prefixedradio = addPrefix(object_default56, prefix); addComponents({ ...prefixedradio }); }; // packages/daisyui/components/skeleton/object.js var object_default57 = { ".skeleton": { "border-radius": "var(--radius-box)", "background-color": "var(--color-base-300)", "@media (prefers-reduced-motion: reduce)": { "transition-duration": "15s" }, "will-change": "background-position", animation: "skeleton 1.8s ease-in-out infinite", "background-image": "linear-gradient( 105deg, #0000 0% 40%, var(--color-base-100) 50%, #0000 60% 100% )", "background-size": "200% auto", "background-repeat": "no-repeat", "background-position-x": "-50%" }, "@keyframes skeleton": { "0%": { "background-position": "150%" }, "100%": { "background-position": "-50%" } } }; // packages/daisyui/components/skeleton/index.js var skeleton_default = ({ addComponents, prefix = "" }) => { const prefixedskeleton = addPrefix(object_default57, prefix); addComponents({ ...prefixedskeleton }); }; // packages/daisyui/components/loading/object.js var object_default58 = { ".loading": { "pointer-events": "none", display: "inline-block", "aspect-ratio": "1 / 1", "background-color": "currentColor", "vertical-align": "middle", width: "calc(var(--size-selector, 0.25rem) * 6)", "mask-size": "100%", "mask-repeat": "no-repeat", "mask-position": "center", "mask-image": `url("data:image/svg+xml,%3Csvg width='24' height='24' stroke='black' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cg transform-origin='center'%3E%3Ccircle cx='12' cy='12' r='9.5' fill='none' stroke-width='3' stroke-linecap='round'%3E%3CanimateTransform attributeName='transform' type='rotate' from='0 12 12' to='360 12 12' dur='2s' repeatCount='indefinite'/%3E%3Canimate attributeName='stroke-dasharray' values='0,150;42,150;42,150' keyTimes='0;0.475;1' dur='1.5s' repeatCount='indefinite'/%3E%3Canimate attributeName='stroke-dashoffset' values='0;-16;-59' keyTimes='0;0.475;1' dur='1.5s' repeatCount='indefinite'/%3E%3C/circle%3E%3C/g%3E%3C/svg%3E")` }, ".loading-spinner": { "mask-image": `url("data:image/svg+xml,%3Csvg width='24' height='24' stroke='black' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cg transform-origin='center'%3E%3Ccircle cx='12' cy='12' r='9.5' fill='none' stroke-width='3' stroke-linecap='round'%3E%3CanimateTransform attributeName='transform' type='rotate' from='0 12 12' to='360 12 12' dur='2s' repeatCount='indefinite'/%3E%3Canimate attributeName='stroke-dasharray' values='0,150;42,150;42,150' keyTimes='0;0.475;1' dur='1.5s' repeatCount='indefinite'/%3E%3Canimate attributeName='stroke-dashoffset' values='0;-16;-59' keyTimes='0;0.475;1' dur='1.5s' repeatCount='indefinite'/%3E%3C/circle%3E%3C/g%3E%3C/svg%3E")` }, ".loading-dots": { "mask-image": `url("data:image/svg+xml,%3Csvg width='24' height='24' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Ccircle cx='4' cy='12' r='3'%3E%3Canimate attributeName='cy' values='12;6;12;12' keyTimes='0;0.286;0.571;1' dur='1.05s' repeatCount='indefinite' keySplines='.33,0,.66,.33;.33,.66,.66,1'/%3E%3C/circle%3E%3Ccircle cx='12' cy='12' r='3'%3E%3Canimate attributeName='cy' values='12;6;12;12' keyTimes='0;0.286;0.571;1' dur='1.05s' repeatCount='indefinite' keySplines='.33,0,.66,.33;.33,.66,.66,1' begin='0.1s'/%3E%3C/circle%3E%3Ccircle cx='20' cy='12' r='3'%3E%3Canimate attributeName='cy' values='12;6;12;12' keyTimes='0;0.286;0.571;1' dur='1.05s' repeatCount='indefinite' keySplines='.33,0,.66,.33;.33,.66,.66,1' begin='0.2s'/%3E%3C/circle%3E%3C/svg%3E")` }, ".loading-ring": { "mask-image": `url("data:image/svg+xml,%3Csvg width='44' height='44' viewBox='0 0 44 44' xmlns='http://www.w3.org/2000/svg' stroke='white'%3E%3Cg fill='none' fill-rule='evenodd' stroke-width='2'%3E%3Ccircle cx='22' cy='22' r='1'%3E%3Canimate attributeName='r' begin='0s' dur='1.8s' values='1;20' calcMode='spline' keyTimes='0;1' keySplines='0.165,0.84,0.44,1' repeatCount='indefinite'/%3E%3Canimate attributeName='stroke-opacity' begin='0s' dur='1.8s' values='1;0' calcMode='spline' keyTimes='0;1' keySplines='0.3,0.61,0.355,1' repeatCount='indefinite'/%3E%3C/circle%3E%3Ccircle cx='22' cy='22' r='1'%3E%3Canimate attributeName='r' begin='-0.9s' dur='1.8s' values='1;20' calcMode='spline' keyTimes='0;1' keySplines='0.165,0.84,0.44,1' repeatCount='indefinite'/%3E%3Canimate attributeName='stroke-opacity' begin='-0.9s' dur='1.8s' values='1;0' calcMode='spline' keyTimes='0;1' keySplines='0.3,0.61,0.355,1' repeatCount='indefinite'/%3E%3C/circle%3E%3C/g%3E%3C/svg%3E")` }, ".loading-ball": { "mask-image": `url("data:image/svg+xml,%3Csvg width='24' height='24' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cellipse cx='12' cy='5' rx='4' ry='4'%3E%3Canimate attributeName='cy' values='5;20;20.5;20;5' keyTimes='0;0.469;0.5;0.531;1' dur='.8s' repeatCount='indefinite' keySplines='.33,0,.66,.33;.33,.66,.66,1'/%3E%3Canimate attributeName='rx' values='4;4;4.8;4;4' keyTimes='0;0.469;0.5;0.531;1' dur='.8s' repeatCount='indefinite'/%3E%3Canimate attributeName='ry' values='4;4;3;4;4' keyTimes='0;0.469;0.5;0.531;1' dur='.8s' repeatCount='indefinite'/%3E%3C/ellipse%3E%3C/svg%3E")` }, ".loading-bars": { "mask-image": `url("data:image/svg+xml,%3Csvg width='24' height='24' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Crect x='1' y='1' width='6' height='22'%3E%3Canimate attributeName='y' values='1;5;1' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite'/%3E%3Canimate attributeName='height' values='22;14;22' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite'/%3E%3Canimate attributeName='opacity' values='1;0.2;1' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite'/%3E%3C/rect%3E%3Crect x='9' y='1' width='6' height='22'%3E%3Canimate attributeName='y' values='1;5;1' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite' begin='-0.65s'/%3E%3Canimate attributeName='height' values='22;14;22' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite' begin='-0.65s'/%3E%3Canimate attributeName='opacity' values='1;0.2;1' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite' begin='-0.65s'/%3E%3C/rect%3E%3Crect x='17' y='1' width='6' height='22'%3E%3Canimate attributeName='y' values='1;5;1' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite' begin='-0.5s'/%3E%3Canimate attributeName='height' values='22;14;22' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite' begin='-0.5s'/%3E%3Canimate attributeName='opacity' values='1;0.2;1' keyTimes='0;0.938;1' dur='.8s' repeatCount='indefinite' begin='-0.5s'/%3E%3C/rect%3E%3C/svg%3E")` }, ".loading-infinity": { "mask-image": `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' style='shape-rendering:auto;' width='200px' height='200px' viewBox='0 0 100 100' preserveAspectRatio='xMidYMid'%3E%3Cpath fill='none' stroke='black' stroke-width='10' stroke-dasharray='205.271 51.318' d='M24.3 30C11.4 30 5 43.3 5 50s6.4 20 19.3 20c19.3 0 32.1-40 51.4-40C88.6 30 95 43.3 95 50s-6.4 20-19.3 20C56.4 70 43.6 30 24.3 30z' stroke-linecap='round' style='transform:scale(0.8);transform-origin:50px 50px'%3E%3Canimate attributeName='stroke-dashoffset' repeatCount='indefinite' dur='2s' keyTimes='0;1' values='0;256.589'/%3E%3C/path%3E%3C/svg%3E")` }, ".loading-xs": { width: "calc(var(--size-selector, 0.25rem) * 4)" }, ".loading-sm": { width: "calc(var(--size-selector, 0.25rem) * 5)" }, ".loading-md": { width: "calc(var(--size-selector, 0.25rem) * 6)" }, ".loading-lg": { width: "calc(var(--size-selector, 0.25rem) * 7)" }, ".loading-xl": { width: "calc(var(--size-selector, 0.25rem) * 8)" } }; // packages/daisyui/components/loading/index.js var loading_default = ({ addComponents, prefix = "" }) => { const prefixedloading = addPrefix(object_default58, prefix); addComponents({ ...prefixedloading }); }; // packages/daisyui/components/validator/object.js var object_default59 = { ".validator": { "&:user-valid, &:has(:user-valid)": { '&, &:focus, &:checked, &[aria-checked="true"], &:focus-within': { "--input-color": "var(--color-success)" } }, "&:user-invalid, &:has(:user-invalid), &[aria-invalid]": { '&, &:focus, &:checked, &[aria-checked="true"], &:focus-within': { "--input-color": "var(--color-error)" }, "& ~ .validator-hint": { visibility: "visible", display: "block", color: "var(--color-error)" } } }, ".validator-hint": { visibility: "hidden", "margin-top": "calc(0.25rem * 2)", "font-size": "0.75rem" } }; // packages/daisyui/components/validator/index.js var validator_default = ({ addComponents, prefix = "" }) => { const prefixedvalidator = addPrefix(object_default59, prefix); addComponents({ ...prefixedvalidator }); }; // packages/daisyui/components/collapse/object.js var object_default60 = { ".collapse:not(td, tr, colgroup)": { visibility: "visible" }, ".collapse": { position: "relative", display: "grid", overflow: "hidden", "border-radius": "var(--radius-box, 1rem)", width: "100%", "grid-template-rows": "max-content 0fr", transition: "grid-template-rows 0.2s", isolation: "isolate", '> input:is([type="checkbox"], [type="radio"])': { "grid-column-start": "1", "grid-row-start": "1", appearance: "none", opacity: 0, "z-index": 1, width: "100%", padding: "1rem", "padding-inline-end": "3rem", "min-height": "3.75rem", transition: "background-color 0.2s ease-out" }, '&:is([open], :focus:not(.collapse-close)), &:not(.collapse-close):has(> input:is([type="checkbox"], [type="radio"]):checked)': { "grid-template-rows": "max-content 1fr" }, '&:is([open], :focus:not(.collapse-close)) > .collapse-content, &:not(.collapse-close) > :where(input:is([type="checkbox"], [type="radio"]):checked ~ .collapse-content)': { visibility: "visible", "min-height": "fit-content" }, '&:focus-visible, &:has(> input:is([type="checkbox"], [type="radio"]):focus-visible)': { "outline-color": "var(--color-base-content)", "outline-style": "solid", "outline-width": "2px", "outline-offset": "2px" }, "&:not(.collapse-close)": { '> input[type="checkbox"], > input[type="radio"]:not(:checked), > .collapse-title': { cursor: "pointer" } }, "&:focus:not(.collapse-close, .collapse[open]) > .collapse-title": { cursor: "unset" }, '&:is([open], :focus:not(.collapse-close)) > :where(.collapse-content), &:not(.collapse-close) > :where(input:is([type="checkbox"], [type="radio"]):checked ~ .collapse-content)': { "padding-bottom": "1rem", transition: "padding 0.2s ease-out, background-color 0.2s ease-out" }, "&:is([open])": { "&.collapse-arrow": { "> .collapse-title:after": { transform: "translateY(-50%) rotate(225deg)" } } }, "&.collapse-open": { "&.collapse-arrow": { "> .collapse-title:after": { transform: "translateY(-50%) rotate(225deg)" } }, "&.collapse-plus": { "> .collapse-title:after": { content: '"−"' } } }, "&.collapse-arrow:focus:not(.collapse-close)": { "> .collapse-title:after": { transform: "translateY(-50%) rotate(225deg)" } }, "&.collapse-arrow:not(.collapse-close)": { '> input:is([type="checkbox"], [type="radio"]):checked ~ .collapse-title:after': { transform: "translateY(-50%) rotate(225deg)" } }, "&[open]": { "&.collapse-plus": { "> .collapse-title:after": { content: '"−"' } } }, "&.collapse-plus:focus:not(.collapse-close)": { "> .collapse-title:after": { content: '"−"' } }, "&.collapse-plus:not(.collapse-close)": { '> input:is([type="checkbox"], [type="radio"]):checked ~ .collapse-title:after': { content: '"−"' } } }, ".collapse-title, .collapse-content": { "grid-column-start": "1", "grid-row-start": "1" }, ".collapse-content": { visibility: "hidden", "grid-column-start": "1", "grid-row-start": "2", "min-height": "0", "padding-left": "1rem", "padding-right": "1rem", cursor: "unset", transition: "visibility 0.2s, padding 0.2s ease-out, background-color 0.2s ease-out" }, ".collapse:is(details)": { width: "100%", "& summary": { position: "relative", display: "block", "&::-webkit-details-marker": { display: "none" } } }, ".collapse:is(details) summary": { outline: "none" }, ".collapse-arrow": { "> .collapse-title:after": { position: "absolute", display: "block", height: "0.5rem", width: "0.5rem", transform: "translateY(-100%) rotate(45deg)", "transition-property": "all", "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)", "transition-duration": "0.2s", top: "1.9rem", "inset-inline-end": "1.4rem", content: '""', "transform-origin": "75% 75%", "box-shadow": "2px 2px", "pointer-events": "none" } }, ".collapse-plus": { "> .collapse-title:after": { position: "absolute", display: "block", height: "0.5rem", width: "0.5rem", "transition-property": "all", "transition-duration": "300ms", "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)", top: "0.9rem", "inset-inline-end": "1.4rem", content: '"+"', "pointer-events": "none" } }, ".collapse-title": { position: "relative", width: "100%", padding: "1rem", "padding-inline-end": "3rem", "min-height": "3.75rem", transition: "background-color 0.2s ease-out" }, ".collapse-open": { "grid-template-rows": "max-content 1fr", "> .collapse-content": { visibility: "visible", "min-height": "fit-content", "padding-bottom": "1rem", transition: "padding 0.2s ease-out, background-color 0.2s ease-out" } } }; // packages/daisyui/components/collapse/index.js var collapse_default = ({ addComponents, prefix = "" }) => { const prefixedcollapse = addPrefix(object_default60, prefix); addComponents({ ...prefixedcollapse }); }; // packages/daisyui/components/swap/object.js var object_default61 = { ".swap": { position: "relative", display: "inline-grid", cursor: "pointer", "place-content": "center", "vertical-align": "middle", "webkit-user-select": "none", "user-select": "none", input: { appearance: "none", border: "none" }, "> *": { "grid-column-start": "1", "grid-row-start": "1", "transition-property": "transform, rotate, opacity", "transition-duration": "0.2s", "transition-timing-function": "cubic-bezier(0, 0, 0.2, 1)" }, ".swap-on, .swap-indeterminate, input:indeterminate ~ .swap-on": { opacity: "0%" }, "input:is(:checked, :indeterminate)": { "& ~ .swap-off": { opacity: "0%" } }, "input:checked ~ .swap-on, input:indeterminate ~ .swap-indeterminate": { opacity: "100%", "backface-visibility": "visible" } }, ".swap-active": { ".swap-off": { opacity: "0%" }, ".swap-on": { opacity: "100%" } }, ".swap-rotate": { ".swap-on, input:indeterminate ~ .swap-on": { rotate: "45deg" }, "input:is(:checked, :indeterminate) ~ .swap-on, &.swap-active .swap-on": { rotate: "0deg" }, "input:is(:checked, :indeterminate) ~ .swap-off, &.swap-active .swap-off": { rotate: "calc(45deg * -1)" } }, ".swap-flip": { "transform-style": "preserve-3d", perspective: "20rem", ".swap-on, .swap-indeterminate, input:indeterminate ~ .swap-on": { transform: "rotateY(180deg)", "backface-visibility": "hidden" }, "input:is(:checked, :indeterminate) ~ .swap-on, &.swap-active .swap-on": { transform: "rotateY(0deg)" }, "input:is(:checked, :indeterminate) ~ .swap-off, &.swap-active .swap-off": { transform: "rotateY(-180deg)", "backface-visibility": "hidden", opacity: "100%" } } }; // packages/daisyui/components/swap/index.js var swap_default = ({ addComponents, prefix = "" }) => { const prefixedswap = addPrefix(object_default61, prefix); addComponents({ ...prefixedswap }); }; // packages/daisyui/utilities/typography/object.js var object_default62 = { ":root .prose": { "--tw-prose-body": "color-mix(in oklab, var(--color-base-content) 80%, #0000)", "--tw-prose-headings": "var(--color-base-content)", "--tw-prose-lead": "var(--color-base-content)", "--tw-prose-links": "var(--color-base-content)", "--tw-prose-bold": "var(--color-base-content)", "--tw-prose-counters": "var(--color-base-content)", "--tw-prose-bullets": "color-mix(in oklab, var(--color-base-content) 50%, #0000)", "--tw-prose-hr": "color-mix(in oklab, var(--color-base-content) 20%, #0000)", "--tw-prose-quotes": "var(--color-base-content)", "--tw-prose-quote-borders": "color-mix(in oklab, var(--color-base-content) 20%, #0000)", "--tw-prose-captions": "color-mix(in oklab, var(--color-base-content) 50%, #0000)", "--tw-prose-code": "var(--color-base-content)", "--tw-prose-pre-code": "var(--color-neutral-content)", "--tw-prose-pre-bg": "var(--color-neutral)", "--tw-prose-th-borders": "color-mix(in oklab, var(--color-base-content) 50%, #0000)", "--tw-prose-td-borders": "color-mix(in oklab, var(--color-base-content) 20%, #0000)", "--tw-prose-kbd": "color-mix(in oklab, var(--color-base-content) 80%, #0000)", ":where(code):not(pre > code)": { "background-color": "var(--color-base-200)", "border-radius": "var(--radius-selector)", border: "var(--border) solid var(--color-base-300)", "padding-inline": "0.5em", "font-weight": "inherit", "&:before, &:after": { display: "none" } } } }; // packages/daisyui/utilities/typography/index.js var typography_default = ({ addUtilities, prefix = "" }) => { const prefixedtypography = addPrefix(object_default62, prefix); addUtilities({ ...prefixedtypography }); }; // packages/daisyui/utilities/glass/object.js var object_default63 = { ".glass": { border: "none", "backdrop-filter": "blur(var(--glass-blur, 40px))", "background-color": "#0000", "background-image": "linear-gradient( 135deg, oklch(100% 0 0 / var(--glass-opacity, 30%)) 0%, oklch(0% 0 0 / 0%) 100% ), linear-gradient( var(--glass-reflect-degree, 100deg), oklch(100% 0 0 / var(--glass-reflect-opacity, 5%)) 25%, oklch(0% 0 0 / 0%) 25% )", "box-shadow": "0 0 0 1px oklch(100% 0 0 / var(--glass-border-opacity, 20%)) inset, 0 0 0 2px oklch(0% 0 0 / 5%)", "text-shadow": "0 1px oklch(0% 0 0 / var(--glass-text-shadow-opacity, 5%))" } }; // packages/daisyui/utilities/glass/index.js var glass_default = ({ addUtilities, prefix = "" }) => { const prefixedglass = addPrefix(object_default63, prefix); addUtilities({ ...prefixedglass }); }; // packages/daisyui/utilities/join/object.js var object_default64 = { ".join": { display: "inline-flex", "align-items": "stretch", "--join-ss": "0", "--join-se": "0", "--join-es": "0", "--join-ee": "0", ":where(.join-item)": { "border-start-start-radius": "var(--join-ss, 0)", "border-start-end-radius": "var(--join-se, 0)", "border-end-start-radius": "var(--join-es, 0)", "border-end-end-radius": "var(--join-ee, 0)", "*": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" } }, "> .join-item:where(:first-child)": { "--join-ss": "var(--radius-field)", "--join-se": "0", "--join-es": "var(--radius-field)", "--join-ee": "0" }, ":first-child:not(:last-child)": { ":where(.join-item)": { "--join-ss": "var(--radius-field)", "--join-se": "0", "--join-es": "var(--radius-field)", "--join-ee": "0" } }, "> .join-item:where(:last-child)": { "--join-ss": "0", "--join-se": "var(--radius-field)", "--join-es": "0", "--join-ee": "var(--radius-field)" }, ":last-child:not(:first-child)": { ":where(.join-item)": { "--join-ss": "0", "--join-se": "var(--radius-field)", "--join-es": "0", "--join-ee": "var(--radius-field)" } }, "> .join-item:where(:only-child)": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" }, ":only-child": { ":where(.join-item)": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" } } }, ".join-item": { "&:where(*:not(:first-child, :disabled, [disabled], .btn-disabled))": { "margin-inline-start": "calc(var(--border, 1px) * -1)", "margin-block-start": "0" } }, ".join-vertical": { "flex-direction": "column", "> .join-item:first-child": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "0", "--join-ee": "0" }, ":first-child:not(:last-child)": { ".join-item": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "0", "--join-ee": "0" } }, "> .join-item:last-child": { "--join-ss": "0", "--join-se": "0", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" }, ":last-child:not(:first-child)": { ".join-item": { "--join-ss": "0", "--join-se": "0", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" } }, "> .join-item:only-child": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" }, ":only-child": { ".join-item": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" } }, ".join-item": { "&:where(*:not(:first-child))": { "margin-inline-start": "0", "margin-block-start": "calc(var(--border, 1px) * -1)" } } }, ".join-horizontal": { "flex-direction": "row", "> .join-item:first-child": { "--join-ss": "var(--radius-field)", "--join-se": "0", "--join-es": "var(--radius-field)", "--join-ee": "0" }, ":first-child:not(:last-child)": { ".join-item": { "--join-ss": "var(--radius-field)", "--join-se": "0", "--join-es": "var(--radius-field)", "--join-ee": "0" } }, "> .join-item:last-child": { "--join-ss": "0", "--join-se": "var(--radius-field)", "--join-es": "0", "--join-ee": "var(--radius-field)" }, ":last-child:not(:first-child)": { ".join-item": { "--join-ss": "0", "--join-se": "var(--radius-field)", "--join-es": "0", "--join-ee": "var(--radius-field)" } }, "> .join-item:only-child": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" }, ":only-child": { ".join-item": { "--join-ss": "var(--radius-field)", "--join-se": "var(--radius-field)", "--join-es": "var(--radius-field)", "--join-ee": "var(--radius-field)" } }, ".join-item": { "&:where(*:not(:first-child))": { "margin-inline-start": "calc(var(--border, 1px) * -1)", "margin-block-start": "0" } } } }; // packages/daisyui/utilities/join/index.js var join_default = ({ addUtilities, prefix = "" }) => { const prefixedjoin = addPrefix(object_default64, prefix); addUtilities({ ...prefixedjoin }); }; // packages/daisyui/utilities/radius/object.js var object_default65 = { ".rounded-box": { "border-radius": "var(--radius-box)" }, ".rounded-field": { "border-radius": "var(--radius-field)" }, ".rounded-selector": { "border-radius": "var(--radius-selector)" }, ".rounded-t-box": { "border-top-left-radius": "var(--radius-box)", "border-top-right-radius": "var(--radius-box)" }, ".rounded-b-box": { "border-bottom-left-radius": "var(--radius-box)", "border-bottom-right-radius": "var(--radius-box)" }, ".rounded-l-box": { "border-top-left-radius": "var(--radius-box)", "border-bottom-left-radius": "var(--radius-box)" }, ".rounded-r-box": { "border-top-right-radius": "var(--radius-box)", "border-bottom-right-radius": "var(--radius-box)" }, ".rounded-tl-box": { "border-top-left-radius": "var(--radius-box)" }, ".rounded-tr-box": { "border-top-right-radius": "var(--radius-box)" }, ".rounded-br-box": { "border-bottom-right-radius": "var(--radius-box)" }, ".rounded-bl-box": { "border-bottom-left-radius": "var(--radius-box)" }, ".rounded-t-field": { "border-top-left-radius": "var(--radius-field)", "border-top-right-radius": "var(--radius-field)" }, ".rounded-b-field": { "border-bottom-left-radius": "var(--radius-field)", "border-bottom-right-radius": "var(--radius-field)" }, ".rounded-l-field": { "border-top-left-radius": "var(--radius-field)", "border-bottom-left-radius": "var(--radius-field)" }, ".rounded-r-field": { "border-top-right-radius": "var(--radius-field)", "border-bottom-right-radius": "var(--radius-field)" }, ".rounded-tl-field": { "border-top-left-radius": "var(--radius-field)" }, ".rounded-tr-field": { "border-top-right-radius": "var(--radius-field)" }, ".rounded-br-field": { "border-bottom-right-radius": "var(--radius-field)" }, ".rounded-bl-field": { "border-bottom-left-radius": "var(--radius-field)" }, ".rounded-t-selector": { "border-top-left-radius": "var(--radius-selector)", "border-top-right-radius": "var(--radius-selector)" }, ".rounded-b-selector": { "border-bottom-left-radius": "var(--radius-selector)", "border-bottom-right-radius": "var(--radius-selector)" }, ".rounded-l-selector": { "border-top-left-radius": "var(--radius-selector)", "border-bottom-left-radius": "var(--radius-selector)" }, ".rounded-r-selector": { "border-top-right-radius": "var(--radius-selector)", "border-bottom-right-radius": "var(--radius-selector)" }, ".rounded-tl-selector": { "border-top-left-radius": "var(--radius-selector)" }, ".rounded-tr-selector": { "border-top-right-radius": "var(--radius-selector)" }, ".rounded-br-selector": { "border-bottom-right-radius": "var(--radius-selector)" }, ".rounded-bl-selector": { "border-bottom-left-radius": "var(--radius-selector)" } }; // packages/daisyui/utilities/radius/index.js var radius_default = ({ addUtilities, prefix = "" }) => { const prefixedradius = addPrefix(object_default65, prefix); addUtilities({ ...prefixedradius }); }; // packages/daisyui/imports.js var base = { rootscrolllock: rootscrolllock_default, rootcolor: rootcolor_default, scrollbar: scrollbar_default, properties: properties_default, rootscrollgutter: rootscrollgutter_default, svg: svg_default }; var components = { drawer: drawer_default, link: link_default, stat: stat_default, carousel: carousel_default, divider: divider_default, mask: mask_default, fieldset: fieldset_default, dropdown: dropdown_default, card: card_default, steps: steps_default, alert: alert_default, kbd: kbd_default, select: select_default, progress: progress_default, fileinput: fileinput_default, modal: modal_default, footer: footer_default, table: table_default, avatar: avatar_default, input: input_default, checkbox: checkbox_default, badge: badge_default, status: status_default, diff: diff_default, hero: hero_default, toggle: toggle_default, stack: stack_default, navbar: navbar_default, label: label_default, menu: menu_default, toast: toast_default, button: button_default, list: list_default, mockup: mockup_default, calendar: calendar_default, indicator: indicator_default, rating: rating_default, tab: tab_default, filter: filter_default, chat: chat_default, radialprogress: radialprogress_default, countdown: countdown_default, tooltip: tooltip_default, timeline: timeline_default, textarea: textarea_default, range: range_default, dock: dock_default, breadcrumbs: breadcrumbs_default, radio: radio_default, skeleton: skeleton_default, loading: loading_default, validator: validator_default, collapse: collapse_default, swap: swap_default }; var utilities = { typography: typography_default, glass: glass_default, join: join_default, radius: radius_default }; // packages/daisyui/index.js var version = "5.0.35"; var daisyui_default = plugin.withOptions((options) => { return ({ addBase, addComponents, addUtilities }) => { const { include, exclude, prefix = "" } = pluginOptionsHandler(options, addBase, object_default, version); const shouldIncludeItem = (name) => { if (include && exclude) { return include.includes(name) && !exclude.includes(name); } if (include) { return include.includes(name); } if (exclude) { return !exclude.includes(name); } return true; }; Object.entries(base).forEach(([name, item]) => { if (!shouldIncludeItem(name)) return; item({ addBase, prefix }); }); Object.entries(components).forEach(([name, item]) => { if (!shouldIncludeItem(name)) return; item({ addComponents, prefix }); }); Object.entries(utilities).forEach(([name, item]) => { if (!shouldIncludeItem(name)) return; item({ addUtilities, prefix }); }); }; }, () => ({ theme: { extend: variables_default } })); /* MIT License Copyright (c) 2020 Pouya Saadeghi – https://daisyui.com Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ ================================================ FILE: installer/templates/phx_assets/heroicons.js.eex ================================================ const plugin = require("tailwindcss/plugin") const fs = require("fs") const path = require("path") module.exports = plugin(function({matchComponents, theme}) { let iconsDir = path.join(__dirname, "..<%= if @in_umbrella, do: "/../.." %>/../deps/heroicons/optimized") let values = {} let icons = [ ["", "/24/outline"], ["-solid", "/24/solid"], ["-mini", "/20/solid"], ["-micro", "/16/solid"] ] icons.forEach(([suffix, dir]) => { fs.readdirSync(path.join(iconsDir, dir)).forEach(file => { let name = path.basename(file, ".svg") + suffix values[name] = {name, fullPath: path.join(iconsDir, dir, file)} }) }) matchComponents({ "hero": ({name, fullPath}) => { let content = fs.readFileSync(fullPath).toString().replace(/\r?\n|\r/g, "") content = encodeURIComponent(content) let size = theme("spacing.6") if (name.endsWith("-mini")) { size = theme("spacing.5") } else if (name.endsWith("-micro")) { size = theme("spacing.4") } return { [`--hero-${name}`]: `url('data:image/svg+xml;utf8,${content}')`, "-webkit-mask": `var(--hero-${name})`, "mask": `var(--hero-${name})`, "mask-repeat": "no-repeat", "background-color": "currentColor", "vertical-align": "middle", "display": "inline-block", "width": size, "height": size } } }, {values}) }) ================================================ FILE: installer/templates/phx_assets/logo.svg.eex ================================================ ================================================ FILE: installer/templates/phx_assets/topbar.js.eex ================================================ /** * @license MIT * topbar 3.0.0 * http://buunguyen.github.io/topbar * Copyright (c) 2024 Buu Nguyen */ (function (window, document) { "use strict"; var canvas, currentProgress, showing, progressTimerId = null, fadeTimerId = null, delayTimerId = null, addEvent = function (elem, type, handler) { if (elem.addEventListener) elem.addEventListener(type, handler, false); else if (elem.attachEvent) elem.attachEvent("on" + type, handler); else elem["on" + type] = handler; }, options = { autoRun: true, barThickness: 3, barColors: { 0: "rgba(26, 188, 156, .9)", ".25": "rgba(52, 152, 219, .9)", ".50": "rgba(241, 196, 15, .9)", ".75": "rgba(230, 126, 34, .9)", "1.0": "rgba(211, 84, 0, .9)", }, shadowBlur: 10, shadowColor: "rgba(0, 0, 0, .6)", className: null, }, repaint = function () { canvas.width = window.innerWidth; canvas.height = options.barThickness * 5; // need space for shadow var ctx = canvas.getContext("2d"); ctx.shadowBlur = options.shadowBlur; ctx.shadowColor = options.shadowColor; var lineGradient = ctx.createLinearGradient(0, 0, canvas.width, 0); for (var stop in options.barColors) lineGradient.addColorStop(stop, options.barColors[stop]); ctx.lineWidth = options.barThickness; ctx.beginPath(); ctx.moveTo(0, options.barThickness / 2); ctx.lineTo( Math.ceil(currentProgress * canvas.width), options.barThickness / 2 ); ctx.strokeStyle = lineGradient; ctx.stroke(); }, createCanvas = function () { canvas = document.createElement("canvas"); var style = canvas.style; style.position = "fixed"; style.top = style.left = style.right = style.margin = style.padding = 0; style.zIndex = 100001; style.display = "none"; if (options.className) canvas.classList.add(options.className); addEvent(window, "resize", repaint); }, topbar = { config: function (opts) { for (var key in opts) if (options.hasOwnProperty(key)) options[key] = opts[key]; }, show: function (delay) { if (showing) return; if (delay) { if (delayTimerId) return; delayTimerId = setTimeout(() => topbar.show(), delay); } else { showing = true; if (fadeTimerId !== null) window.cancelAnimationFrame(fadeTimerId); if (!canvas) createCanvas(); if (!canvas.parentElement) document.body.appendChild(canvas); canvas.style.opacity = 1; canvas.style.display = "block"; topbar.progress(0); if (options.autoRun) { (function loop() { progressTimerId = window.requestAnimationFrame(loop); topbar.progress( "+" + 0.05 * Math.pow(1 - Math.sqrt(currentProgress), 2) ); })(); } } }, progress: function (to) { if (typeof to === "undefined") return currentProgress; if (typeof to === "string") { to = (to.indexOf("+") >= 0 || to.indexOf("-") >= 0 ? currentProgress : 0) + parseFloat(to); } currentProgress = to > 1 ? 1 : to; repaint(); return currentProgress; }, hide: function () { clearTimeout(delayTimerId); delayTimerId = null; if (!showing) return; showing = false; if (progressTimerId != null) { window.cancelAnimationFrame(progressTimerId); progressTimerId = null; } (function loop() { if (topbar.progress("+.1") >= 1) { canvas.style.opacity -= 0.05; if (canvas.style.opacity <= 0.05) { canvas.style.display = "none"; fadeTimerId = null; return; } } fadeTimerId = window.requestAnimationFrame(loop); })(); }, }; if (typeof module === "object" && typeof module.exports === "object") { module.exports = topbar; } else if (typeof define === "function" && define.amd) { define(function () { return topbar; }); } else { this.topbar = topbar; } }.call(this, window, document)); ================================================ FILE: installer/templates/phx_assets/tsconfig.json.eex ================================================ // This file is needed on most editors to enable the intelligent autocompletion // of LiveView's JavaScript API methods. You can safely delete it if you don't need it. // // Note: This file assumes a basic esbuild setup without node_modules. // We include a generic paths alias to deps to mimic how esbuild resolves // the Phoenix and LiveView JavaScript assets. // If you have a package.json in your project, you should remove the // paths configuration and instead add the phoenix dependencies to the // dependencies section of your package.json: // // { // ... // "dependencies": { // ..., // "phoenix": "../deps/phoenix", // "phoenix_html": "../deps/phoenix_html", // "phoenix_live_view": "../deps/phoenix_live_view" // } // } // // Feel free to adjust this configuration however you need. { "compilerOptions": { "baseUrl": ".", "paths": { "*": ["../deps/*"] }, "allowJs": true, "noEmit": true }, "include": ["js/**/*"] } ================================================ FILE: installer/templates/phx_ecto/data_case.ex.eex ================================================ defmodule <%= @app_module %>.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 <%= @app_module %>.DataCase, async: true`, although this option is not recommended for other databases. """ use ExUnit.CaseTemplate using do quote do alias <%= @app_module %>.Repo import Ecto import Ecto.Changeset import Ecto.Query import <%= @app_module %>.DataCase end end setup tags do <%= @app_module %>.DataCase.setup_sandbox(tags) :ok end @doc """ Sets up the sandbox based on the test tags. """ def setup_sandbox(tags) do <%= @adapter_config[:test_setup] %> 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 ================================================ FILE: installer/templates/phx_ecto/formatter.exs.eex ================================================ [ import_deps: [:ecto_sql], inputs: ["*.exs"] ] ================================================ FILE: installer/templates/phx_ecto/repo.ex.eex ================================================ defmodule <%= @app_module %>.Repo do use Ecto.Repo, otp_app: :<%= @app_name %>, adapter: <%= inspect @adapter_module %> end ================================================ FILE: installer/templates/phx_ecto/seeds.exs.eex ================================================ # 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: # # <%= @app_module %>.Repo.insert!(%<%= @app_module %>.SomeSchema{}) # # We recommend using the bang functions (`insert!`, `update!` # and so on) as they will fail if something goes wrong. ================================================ FILE: installer/templates/phx_gettext/en/LC_MESSAGES/errors.po.eex ================================================ ## `msgid`s in this file come from POT (.pot) files. ## ## Do not add, change, or remove `msgid`s manually here as ## they're tied to the ones in the corresponding POT file ## (with the same domain). ## ## Use `mix gettext.extract --merge` or `mix gettext.merge` ## to merge POT files into PO files. msgid "" msgstr "" "Language: en\n"<%= if @ecto do %> ## From Ecto.Changeset.cast/4 msgid "can't be blank" msgstr "" ## From Ecto.Changeset.unique_constraint/3 msgid "has already been taken" msgstr "" ## From Ecto.Changeset.put_change/3 msgid "is invalid" msgstr "" ## From Ecto.Changeset.validate_acceptance/3 msgid "must be accepted" msgstr "" ## From Ecto.Changeset.validate_format/3 msgid "has invalid format" msgstr "" ## From Ecto.Changeset.validate_subset/3 msgid "has an invalid entry" msgstr "" ## From Ecto.Changeset.validate_exclusion/3 msgid "is reserved" msgstr "" ## From Ecto.Changeset.validate_confirmation/3 msgid "does not match confirmation" msgstr "" ## From Ecto.Changeset.no_assoc_constraint/3 msgid "is still associated with this entry" msgstr "" msgid "are still associated with this entry" msgstr "" ## From Ecto.Changeset.validate_length/3 msgid "should have %{count} item(s)" msgid_plural "should have %{count} item(s)" msgstr[0] "" msgstr[1] "" msgid "should be %{count} character(s)" msgid_plural "should be %{count} character(s)" msgstr[0] "" msgstr[1] "" msgid "should be %{count} byte(s)" msgid_plural "should be %{count} byte(s)" msgstr[0] "" msgstr[1] "" msgid "should have at least %{count} item(s)" msgid_plural "should have at least %{count} item(s)" msgstr[0] "" msgstr[1] "" msgid "should be at least %{count} character(s)" msgid_plural "should be at least %{count} character(s)" msgstr[0] "" msgstr[1] "" msgid "should be at least %{count} byte(s)" msgid_plural "should be at least %{count} byte(s)" msgstr[0] "" msgstr[1] "" msgid "should have at most %{count} item(s)" msgid_plural "should have at most %{count} item(s)" msgstr[0] "" msgstr[1] "" msgid "should be at most %{count} character(s)" msgid_plural "should be at most %{count} character(s)" msgstr[0] "" msgstr[1] "" msgid "should be at most %{count} byte(s)" msgid_plural "should be at most %{count} byte(s)" msgstr[0] "" msgstr[1] "" ## From Ecto.Changeset.validate_number/3 msgid "must be less than %{number}" msgstr "" msgid "must be greater than %{number}" msgstr "" msgid "must be less than or equal to %{number}" msgstr "" msgid "must be greater than or equal to %{number}" msgstr "" msgid "must be equal to %{number}" msgstr ""<% end %> ================================================ FILE: installer/templates/phx_gettext/errors.pot.eex ================================================ ## This is a PO Template file. ## ## `msgid`s here are often extracted from source code. ## Add new translations manually only if they're dynamic ## translations that can't be statically extracted. ## ## Run `mix gettext.extract` to bring this file up to ## date. Leave `msgstr`s empty as changing them here has no ## effect: edit them in PO (`.po`) files instead. <%= if @ecto do %>## From Ecto.Changeset.cast/4 msgid "can't be blank" msgstr "" ## From Ecto.Changeset.unique_constraint/3 msgid "has already been taken" msgstr "" ## From Ecto.Changeset.put_change/3 msgid "is invalid" msgstr "" ## From Ecto.Changeset.validate_acceptance/3 msgid "must be accepted" msgstr "" ## From Ecto.Changeset.validate_format/3 msgid "has invalid format" msgstr "" ## From Ecto.Changeset.validate_subset/3 msgid "has an invalid entry" msgstr "" ## From Ecto.Changeset.validate_exclusion/3 msgid "is reserved" msgstr "" ## From Ecto.Changeset.validate_confirmation/3 msgid "does not match confirmation" msgstr "" ## From Ecto.Changeset.no_assoc_constraint/3 msgid "is still associated with this entry" msgstr "" msgid "are still associated with this entry" msgstr "" ## From Ecto.Changeset.validate_length/3 msgid "should have %{count} item(s)" msgid_plural "should have %{count} item(s)" msgstr[0] "" msgstr[1] "" msgid "should be %{count} character(s)" msgid_plural "should be %{count} character(s)" msgstr[0] "" msgstr[1] "" msgid "should be %{count} byte(s)" msgid_plural "should be %{count} byte(s)" msgstr[0] "" msgstr[1] "" msgid "should have at least %{count} item(s)" msgid_plural "should have at least %{count} item(s)" msgstr[0] "" msgstr[1] "" msgid "should be at least %{count} character(s)" msgid_plural "should be at least %{count} character(s)" msgstr[0] "" msgstr[1] "" msgid "should be at least %{count} byte(s)" msgid_plural "should be at least %{count} byte(s)" msgstr[0] "" msgstr[1] "" msgid "should have at most %{count} item(s)" msgid_plural "should have at most %{count} item(s)" msgstr[0] "" msgstr[1] "" msgid "should be at most %{count} character(s)" msgid_plural "should be at most %{count} character(s)" msgstr[0] "" msgstr[1] "" msgid "should be at most %{count} byte(s)" msgid_plural "should be at most %{count} byte(s)" msgstr[0] "" msgstr[1] "" ## From Ecto.Changeset.validate_number/3 msgid "must be less than %{number}" msgstr "" msgid "must be greater than %{number}" msgstr "" msgid "must be less than or equal to %{number}" msgstr "" msgid "must be greater than or equal to %{number}" msgstr "" msgid "must be equal to %{number}" msgstr ""<% end %> ================================================ FILE: installer/templates/phx_gettext/gettext.ex.eex ================================================ defmodule <%= @web_namespace %>.Gettext do @moduledoc """ A module providing Internationalization with a gettext-based API. By using [Gettext](https://hexdocs.pm/gettext), your module compiles translations that you can use in your application. To use this Gettext backend module, call `use Gettext` and pass it as an option: use Gettext, backend: <%= @web_namespace %>.Gettext # Simple translation gettext("Here is the string to translate") # Plural translation ngettext("Here is the string to translate", "Here are the strings to translate", 3) # Domain-based translation dgettext("errors", "Here is the error message to translate") See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage. """ use Gettext.Backend, otp_app: :<%= @web_app_name %> end ================================================ FILE: installer/templates/phx_mailer/lib/app_name/mailer.ex.eex ================================================ defmodule <%= @app_module %>.Mailer do use Swoosh.Mailer, otp_app: :<%= @app_name %> end ================================================ FILE: installer/templates/phx_single/README.md.eex ================================================ # <%= @app_module %> 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 ================================================ FILE: installer/templates/phx_single/config/config.exs.eex ================================================ # 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 <%= if @namespaced? || @ecto || @generators do %> config :<%= @app_name %><%= if @namespaced? do %>, namespace: <%= @app_module %><% end %><%= if @ecto do %>, ecto_repos: [<%= @app_module %>.Repo]<% end %><%= if @generators do %>, generators: <%= inspect @generators %><% end %><% end %> # Configure the endpoint config :<%= @app_name %>, <%= @endpoint_module %>, url: [host: "localhost"], adapter: <%= inspect @web_adapter_module %>, render_errors: [ formats: [<%= if @html do%>html: <%= @web_namespace %>.ErrorHTML, <% end %>json: <%= @web_namespace %>.ErrorJSON], layout: false ], pubsub_server: <%= @app_module %>.PubSub, live_view: [signing_salt: "<%= @lv_signing_salt %>"]<%= if @mailer do %> # Configure the mailer # # By default it uses the "Local" adapter which stores the emails # locally. You can see the emails in your browser, at "/dev/mailbox". # # For production it's recommended to configure a different adapter # at the `config/runtime.exs`. config :<%= @app_name %>, <%= @app_module %>.Mailer, adapter: Swoosh.Adapters.Local<% end %><%= if @javascript do %> # Configure esbuild (the version is required) config :esbuild, version: "0.25.4", <%= @app_name %>: [ args: ~w(js/app.js --bundle --target=es2022 --outdir=../priv/static/assets/js --external:/fonts/* --external:/images/* --alias:@=.), cd: Path.expand("..<%= if @in_umbrella, do: "/apps/#{@app_name}" %>/assets", __DIR__), env: %{"NODE_PATH" => [Path.expand("../deps", __DIR__), Mix.Project.build_path()]} ]<% end %><%= if @css do %> # Configure tailwind (the version is required) config :tailwind, version: "4.1.12", <%= @app_name %>: [ args: ~w( --input=assets/css/app.css --output=priv/static/assets/css/app.css ), cd: Path.expand("..<%= if @in_umbrella, do: "/apps/#{@app_name}" %>", __DIR__), ]<% end %> # 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 # 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" ================================================ FILE: installer/templates/phx_single/config/dev.exs.eex ================================================ import Config # 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 :<%= @app_name %>, <%= @endpoint_module %>,<%= if @inside_docker_env? do %> # Bind to 0.0.0.0 to expose the server to the docker host machine. # This makes make the service accessible from any network interface. # Change to `ip: {127, 0, 0, 1}` to allow access only from the server machine. http: [ip: {0, 0, 0, 0}],<% else %> # 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}],<% end %> check_origin: false, code_reloader: true, debug_errors: true, secret_key_base: "<%= @secret_key_base_dev %>", watchers: <%= if @javascript or @css do %>[<%= if @javascript do %> esbuild: {Esbuild, :install_and_run, [:<%= @app_name %>, ~w(--sourcemap=inline --watch)]}<%= if @css, do: "," %><% end %><%= if @css do %> tailwind: {Tailwind, :install_and_run, [:<%= @app_name %>, ~w(--watch)]}<% end %> ]<% else %>[]<% end %> # ## 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.<%= if @html do %> # Reload browser tabs when matching files change. config :<%= @app_name %>, <%= @endpoint_module %>, live_reload: [ web_console_logger: true, patterns: [ # Static assets, except user uploads ~r"priv/static/(?!uploads/).*\.(js|css|png|jpeg|jpg|gif|svg)$"<%= @config_regex_E %>,<%= if @gettext do %> # Gettext translations ~r"priv/gettext/.*\.po$"<%= @config_regex_E %>,<% end %> # Router, Controllers, LiveViews and LiveComponents ~r"lib/<%= @lib_web_name %>/router\.ex$"<%= @config_regex_E %>, ~r"lib/<%= @lib_web_name %>/(controllers|live|components)/.*\.(ex|heex)$"<%= @config_regex_E %> ] ]<% end %> # Enable dev routes for dashboard and mailbox config :<%= @app_name %>, 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<%= if @html do %> config :phoenix_live_view, # Include debug annotations and locations in rendered markup. # Changing this configuration will require mix clean and a full recompile. debug_heex_annotations: true, debug_attributes: true, # Enable helpful, but potentially expensive runtime checks enable_expensive_runtime_checks: true<% end %><%= if @mailer do %> # Disable swoosh api client as it is only required for production adapters. config :swoosh, :api_client, false<% end %> ================================================ FILE: installer/templates/phx_single/config/prod.exs.eex ================================================ import Config <%= if @javascript or @css do %> # Note we also include the path to a cache manifest # containing the digested version of static files. This # manifest is generated by the `mix assets.deploy` task, # which you should run after static files are built and # before starting your production server. config :<%= @web_app_name %>, <%= @endpoint_module %>, cache_static_manifest: "priv/static/cache_manifest.json" <% end %># 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 :<%= @web_app_name %>, <%= @endpoint_module %>, force_ssl: [ rewrite_on: [:x_forwarded_proto], exclude: [ # paths: ["/health"], hosts: ["localhost", "127.0.0.1"] ] ]<%= if @mailer do %> # Configure Swoosh API Client config :swoosh, api_client: Swoosh.ApiClient.Req # Disable Swoosh Local Memory Storage config :swoosh, local: false<% end %> # 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. ================================================ FILE: installer/templates/phx_single/config/runtime.exs.eex ================================================ 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/<%= @app_name %> 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 :<%= @app_name %>, <%= @endpoint_module %>, server: true end config :<%= @app_name %>, <%= @endpoint_module %>, http: [port: String.to_integer(System.get_env("PORT", "4000"))] if config_env() == :prod do # 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 :<%= @app_name %>, :dns_cluster_query, System.get_env("DNS_CLUSTER_QUERY") config :<%= @app_name %>, <%= @endpoint_module %>, 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 <%= @web_adapter_docs %> # 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 :<%= @web_app_name %>, <%= @endpoint_module %>, # 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 :<%= @web_app_name %>, <%= @endpoint_module %>, # force_ssl: [hsts: true] # # Check `Plug.SSL` for all available options in `force_ssl`.<%= if @mailer do %> # ## Configuring the mailer # # In production you need to configure the mailer to use a different adapter. # Here is an example configuration for Mailgun: # # config :<%= @app_name %>, <%= @app_module %>.Mailer, # adapter: Swoosh.Adapters.Mailgun, # api_key: System.get_env("MAILGUN_API_KEY"), # domain: System.get_env("MAILGUN_DOMAIN") # # Most non-SMTP adapters require an API client. Swoosh supports Req, Hackney, # and Finch out-of-the-box. This configuration is typically done at # compile-time in your config/prod.exs: # # config :swoosh, :api_client, Swoosh.ApiClient.Req # # See https://hexdocs.pm/swoosh/Swoosh.html#module-installation for details.<% end %> end ================================================ FILE: installer/templates/phx_single/config/test.exs.eex ================================================ import Config # We don't run a server during test. If one is required, # you can enable the server option below. config :<%= @app_name %>, <%= @endpoint_module %>, http: [ip: {127, 0, 0, 1}, port: 4002], secret_key_base: "<%= @secret_key_base_test %>", server: false<%= if @mailer do %> # In test we don't send emails config :<%= @app_name %>, <%= @app_module %>.Mailer, adapter: Swoosh.Adapters.Test # Disable swoosh api client as it is only required for production adapters config :swoosh, :api_client, false<% end %> # 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<%= if @html do %> # Enable helpful, but potentially expensive runtime checks config :phoenix_live_view, enable_expensive_runtime_checks: true<% end %> # Sort query params output of verified routes for robust url comparisons config :phoenix, sort_verified_routes_query_params: true ================================================ FILE: installer/templates/phx_single/formatter.exs.eex ================================================ [ import_deps: [<%= if @ecto do %>:ecto, :ecto_sql, <% end %>:phoenix],<%= if @ecto do %> subdirectories: ["priv/*/migrations"],<% end %><%= if @html do %> plugins: [Phoenix.LiveView.HTMLFormatter],<% end %> inputs: [<%= if @html do %>"*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}"<% else %>"*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"<% end %><%= if @ecto do %>, "priv/*/seeds.exs"<% end %>] ] ================================================ FILE: installer/templates/phx_single/gitignore.eex ================================================ # 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"). <%= @app_name %>-*.tar <%= if @javascript or @css do %> # Ignore assets that are produced by build tools. /priv/static/assets/ # Ignore digested assets cache. /priv/static/cache_manifest.json # In case you use Node.js/npm, you want to ignore these. npm-debug.log /assets/node_modules/ <% end %><%= if @adapter_app == :ecto_sqlite3 do %> # Database files *.db *.db-* <% end %> ================================================ FILE: installer/templates/phx_single/lib/app_name/application.ex.eex ================================================ defmodule <%= @app_module %>.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 = [ <%= @web_namespace %>.Telemetry,<%= if @ecto do %> <%= @app_module %>.Repo,<% end %><%= if @adapter_app == :ecto_sqlite3 do %> {Ecto.Migrator, repos: Application.fetch_env!(<%= inspect(String.to_atom(@app_name)) %>, :ecto_repos), skip: skip_migrations?()},<% end %> {DNSCluster, query: Application.get_env(<%= inspect(String.to_atom(@app_name)) %>, :dns_cluster_query) || :ignore}, {Phoenix.PubSub, name: <%= @app_module %>.PubSub}, # Start a worker by calling: <%= @app_module %>.Worker.start_link(arg) # {<%= @app_module %>.Worker, arg}, # Start to serve requests, typically the last entry <%= @endpoint_module %> ] # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options opts = [strategy: :one_for_one, name: <%= @app_module %>.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 <%= @endpoint_module %>.config_change(changed, removed) :ok end<%= if @adapter_app == :ecto_sqlite3 do %> defp skip_migrations?() do # By default, sqlite migrations are run when using a release System.get_env("RELEASE_NAME") == nil end<% end %> end ================================================ FILE: installer/templates/phx_single/lib/app_name.ex.eex ================================================ defmodule <%= @app_module %> do @moduledoc """ <%= @app_module %> 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 ================================================ FILE: installer/templates/phx_single/lib/app_name_web.ex.eex ================================================ defmodule <%= @web_namespace %> 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 <%= @web_namespace %>, :controller use <%= @web_namespace %>, :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<%= if @html do %> import Phoenix.LiveView.Router<% end %> end end def channel do quote do use Phoenix.Channel end end def controller do quote do use Phoenix.Controller, formats: [:html, :json]<%= if @gettext do %> use Gettext, backend: <%= @web_namespace %>.Gettext<% end %> import Plug.Conn unquote(verified_routes()) end end<%= if @html do %> def live_view do quote do use Phoenix.LiveView unquote(html_helpers()) end end def live_component do quote do use Phoenix.LiveComponent unquote(html_helpers()) end end def html do quote do use Phoenix.Component # Import convenience functions from controllers import Phoenix.Controller, only: [get_csrf_token: 0, view_module: 1, view_template: 1] # Include general helpers for rendering HTML unquote(html_helpers()) end end defp html_helpers do quote do<%= if @gettext do %> # Translation use Gettext, backend: <%= @web_namespace %>.Gettext <% end %> # HTML escaping functionality import Phoenix.HTML # Core UI components import <%= @web_namespace %>.CoreComponents # Common modules used in templates alias Phoenix.LiveView.JS alias <%= @web_namespace %>.Layouts # Routes generation with the ~p sigil unquote(verified_routes()) end end<% end %> def verified_routes do quote do use Phoenix.VerifiedRoutes, endpoint: <%= @endpoint_module %>, router: <%= @web_namespace %>.Router, statics: <%= @web_namespace %>.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 ================================================ FILE: installer/templates/phx_single/mix.exs.eex ================================================ defmodule <%= @app_module %>.MixProject do use Mix.Project def project do [ app: :<%= @app_name %>, version: "0.1.0",<%= if @in_umbrella do %> build_path: "../../_build", config_path: "../../config/config.exs", deps_path: "../../deps", lockfile: "../../mix.lock",<% end %> elixir: "~> 1.15", elixirc_paths: elixirc_paths(Mix.env()), start_permanent: Mix.env() == :prod, aliases: aliases(), deps: deps(),<%= if @html do %> compilers: [:phoenix_live_view] ++ Mix.compilers(),<% end %> listeners: [Phoenix.CodeReloader] ] end # Configuration for the OTP application. # # Type `mix help compile.app` for more information. def application do [ mod: {<%= @app_module %>.Application, []}, extra_applications: [:logger, :runtime_tools] ] 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_dep %>,<%= if @ecto do %> {:phoenix_ecto, "~> 4.5"}, {:ecto_sql, "~> 3.13"}, {<%= inspect @adapter_app %>, ">= 0.0.0"},<% end %><%= if @html do %> {:phoenix_html, "~> 4.1"}, {:phoenix_live_reload, "~> 1.2", only: :dev}, {:phoenix_live_view, "~> 1.1.0"}, {:lazy_html, ">= 0.1.0", only: :test},<% end %><%= if @dashboard do %> {:phoenix_live_dashboard, "~> 0.8.3"},<% end %><%= if @javascript do %> {:esbuild, "~> 0.10", runtime: Mix.env() == :dev},<% end %><%= if @css do %> {:tailwind, "~> 0.3", runtime: Mix.env() == :dev}, {:heroicons, github: "tailwindlabs/heroicons", tag: "v2.2.0", sparse: "optimized", app: false, compile: false, depth: 1},<% end %><%= if @mailer do %> {:swoosh, "~> 1.16"}, {:req, "~> 0.5"},<% end %> {:telemetry_metrics, "~> 1.0"}, {:telemetry_poller, "~> 1.0"},<%= if @gettext do %> {:gettext, "~> 1.0"},<% end %> {:jason, "~> 1.2"}, {:dns_cluster, "~> 0.2.0"}, {<%= inspect @web_adapter_app %>, "<%= @web_adapter_vsn %>"} ] 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"<%= if @ecto do %>, "ecto.setup"<% end %><%= if @asset_builders != [] do %>, "assets.setup", "assets.build"<% end %>]<%= if @ecto do %>, "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"]<% end %><%= if @asset_builders != [] do %>, "assets.setup": <%= inspect Enum.map(@asset_builders, &"#{&1}.install --if-missing") %>, "assets.build": <%= inspect ["compile" | Enum.map(@asset_builders, &"#{&1} #{@app_name}")] %>, "assets.deploy": [ <%= Enum.map(@asset_builders, &" \"#{&1} #{@app_name} --minify\",\n") ++ [" \"phx.digest\""] %> ]<% end %>, precommit: ["compile --warnings-as-errors", "deps.unlock --unused", "format", "test"] ] end end ================================================ FILE: installer/templates/phx_single/test/test_helper.exs.eex ================================================ ExUnit.start()<%= if @ecto do %> <%= @adapter_config[:test_setup_all] %><% end %> ================================================ FILE: installer/templates/phx_static/app.css ================================================ /* This file is for your main application CSS */ ================================================ FILE: installer/templates/phx_static/app.js ================================================ // For Phoenix.HTML support, including form and button helpers // copy the following scripts into your javascript bundle: // * deps/phoenix_html/priv/static/phoenix_html.js // For Phoenix.Channels support, copy the following scripts // into your javascript bundle: // * deps/phoenix/priv/static/phoenix.js // For Phoenix.LiveView support, copy the following scripts // into your javascript bundle: // * deps/phoenix_live_view/priv/static/phoenix_live_view.js // Handle flash close // (you can safely remove this if you don't use the default flash component) document.querySelectorAll("[role=alert][data-flash]").forEach((el) => { el.addEventListener("click", () => { el.setAttribute("hidden", ""); }); }); ================================================ FILE: installer/templates/phx_static/default.css ================================================ /* These are daisyUI styles for styling the default CoreComponents and generator files * included to prevent shipping a completely unstyled page, even as you selected --no-tailwind. * You can safely remove the whole file and all references to "default.css". */ /*! tailwindcss v4.0.9 | MIT License | https://tailwindcss.com */ @layer theme, base, components, utilities; @layer theme { :root, :host { --font-sans: ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol', 'Noto Color Emoji'; --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace; --color-black: #000; --spacing: 0.25rem; --container-sm: 24rem; --container-xl: 36rem; --container-2xl: 42rem; --text-sm: 0.875rem; --text-sm--line-height: calc(1.25 / 0.875); --text-lg: 1.125rem; --text-lg--line-height: calc(1.75 / 1.125); --font-weight-semibold: 600; --font-weight-bold: 700; --tracking-tighter: -0.05em; --radius-lg: 0.5rem; --ease-in: cubic-bezier(0.4, 0, 1, 1); --ease-out: cubic-bezier(0, 0, 0.2, 1); --animate-spin: spin 1s linear infinite; --default-transition-duration: 150ms; --default-transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1); --default-font-family: var(--font-sans); --default-font-feature-settings: var(--font-sans--font-feature-settings); --default-font-variation-settings: var(--font-sans--font-variation-settings); --default-mono-font-family: var(--font-mono); --default-mono-font-feature-settings: var(--font-mono--font-feature-settings); --default-mono-font-variation-settings: var(--font-mono--font-variation-settings); } } @layer base { *, ::after, ::before, ::backdrop, ::file-selector-button { box-sizing: border-box; margin: 0; padding: 0; border: 0 solid; } html, :host { line-height: 1.5; -webkit-text-size-adjust: 100%; tab-size: 4; font-family: var( --default-font-family, ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol', 'Noto Color Emoji' ); font-feature-settings: var(--default-font-feature-settings, normal); font-variation-settings: var(--default-font-variation-settings, normal); -webkit-tap-highlight-color: transparent; } body { line-height: inherit; } hr { height: 0; color: inherit; border-top-width: 1px; } abbr:where([title]) { -webkit-text-decoration: underline dotted; text-decoration: underline dotted; } h1, h2, h3, h4, h5, h6 { font-size: inherit; font-weight: inherit; } a { color: inherit; -webkit-text-decoration: inherit; text-decoration: inherit; } b, strong { font-weight: bolder; } code, kbd, samp, pre { font-family: var( --default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace ); font-feature-settings: var(--default-mono-font-feature-settings, normal); font-variation-settings: var(--default-mono-font-variation-settings, normal); font-size: 1em; } small { font-size: 80%; } sub, sup { font-size: 75%; line-height: 0; position: relative; vertical-align: baseline; } sub { bottom: -0.25em; } sup { top: -0.5em; } table { text-indent: 0; border-color: inherit; border-collapse: collapse; } :-moz-focusring { outline: auto; } progress { vertical-align: baseline; } summary { display: list-item; } ol, ul, menu { list-style: none; } img, svg, video, canvas, audio, iframe, embed, object { display: block; vertical-align: middle; } img, video { max-width: 100%; height: auto; } button, input, select, optgroup, textarea, ::file-selector-button { font: inherit; font-feature-settings: inherit; font-variation-settings: inherit; letter-spacing: inherit; color: inherit; border-radius: 0; background-color: transparent; opacity: 1; } :where(select:is([multiple], [size])) optgroup { font-weight: bolder; } :where(select:is([multiple], [size])) optgroup option { padding-inline-start: 20px; } ::file-selector-button { margin-inline-end: 4px; } ::placeholder { opacity: 1; color: color-mix(in oklab, currentColor 50%, transparent); } textarea { resize: vertical; } ::-webkit-search-decoration { -webkit-appearance: none; } ::-webkit-date-and-time-value { min-height: 1lh; text-align: inherit; } ::-webkit-datetime-edit { display: inline-flex; } ::-webkit-datetime-edit-fields-wrapper { padding: 0; } ::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field { padding-block: 0; } :-moz-ui-invalid { box-shadow: none; } button, input:where([type='button'], [type='reset'], [type='submit']), ::file-selector-button { appearance: button; } ::-webkit-inner-spin-button, ::-webkit-outer-spin-button { height: auto; } [hidden]:where(:not([hidden='until-found'])) { display: none !important; } } @layer utilities { .menu { display: flex; width: fit-content; flex-direction: column; flex-wrap: wrap; padding: calc(0.25rem * 2); --menu-active-fg: var(--color-neutral-content); --menu-active-bg: var(--color-neutral); font-size: 0.875rem; :where(li ul) { position: relative; margin-inline-start: calc(0.25rem * 4); padding-inline-start: calc(0.25rem * 2); white-space: nowrap; &:before { position: absolute; inset-inline-start: calc(0.25rem * 0); top: calc(0.25rem * 3); bottom: calc(0.25rem * 3); background-color: var(--color-base-content); opacity: 10%; width: var(--border); content: ""; } } :where(li > .menu-dropdown:not(.menu-dropdown-show)) { display: none; } :where(li:not(.menu-title) > *:not(ul, details, .menu-title, .btn)), :where(li:not(.menu-title) > details > summary:not(.menu-title)) { display: grid; grid-auto-flow: column; align-content: flex-start; align-items: center; gap: calc(0.25rem * 2); border-radius: var(--radius-field); padding-inline: calc(0.25rem * 3); padding-block: calc(0.25rem * 1.5); text-align: start; transition-property: color, background-color, box-shadow; transition-duration: 0.2s; transition-timing-function: cubic-bezier(0, 0, 0.2, 1); grid-auto-columns: minmax(auto, max-content) auto max-content; text-wrap: balance; user-select: none; } :where(li > details > summary) { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } &::-webkit-details-marker { display: none; } } :where(li > details > summary), :where(li > .menu-dropdown-toggle) { &:after { justify-self: flex-end; display: block; height: 0.375rem; width: 0.375rem; rotate: -135deg; translate: 0 -1px; transition-property: rotate, translate; transition-duration: 0.2s; content: ""; transform-origin: 50% 50%; box-shadow: 2px 2px inset; pointer-events: none; } } :where(li > details[open] > summary):after, :where(li > .menu-dropdown-toggle.menu-dropdown-show):after { rotate: 45deg; translate: 0 1px; } :where( li:not(.menu-title, .disabled) > *:not(ul, details, .menu-title), li:not(.menu-title, .disabled) > details > summary:not(.menu-title) ):not(.menu-active, :active, .btn) { &.menu-focus, &:focus-visible { cursor: pointer; background-color: color-mix(in oklab, var(--color-base-content) 10%, transparent); color: var(--color-base-content); --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } } } :where( li:not(.menu-title, .disabled) > *:not(ul, details, .menu-title):not(.menu-active, :active, .btn):hover, li:not(.menu-title, .disabled) > details > summary:not(.menu-title):not(.menu-active, :active, .btn):hover ) { cursor: pointer; background-color: color-mix(in oklab, var(--color-base-content) 10%, transparent); --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } box-shadow: 0 1px oklch(0% 0 0 / 0.01) inset, 0 -1px oklch(100% 0 0 / 0.01) inset; } :where(li:empty) { background-color: var(--color-base-content); opacity: 10%; margin: 0.5rem 1rem; height: 1px; } :where(li) { position: relative; display: flex; flex-shrink: 0; flex-direction: column; flex-wrap: wrap; align-items: stretch; .badge { justify-self: flex-end; } & > *:not(ul, .menu-title, details, .btn):active, & > *:not(ul, .menu-title, details, .btn).menu-active, & > details > summary:active { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } color: var(--menu-active-fg); background-color: var(--menu-active-bg); background-size: auto, calc(var(--noise) * 100%); background-image: none, var(--fx-noise); &:not(&:active) { box-shadow: 0 2px calc(var(--depth) * 3px) -2px var(--menu-active-bg); } } &.menu-disabled { pointer-events: none; color: color-mix(in oklab, var(--color-base-content) 20%, transparent); } } .dropdown:focus-within { .menu-dropdown-toggle:after { rotate: 45deg; translate: 0 1px; } } .dropdown-content { margin-top: calc(0.25rem * 2); padding: calc(0.25rem * 2); &:before { display: none; } } } .btn { :where(&) { width: unset; } display: inline-flex; flex-shrink: 0; cursor: pointer; flex-wrap: nowrap; align-items: center; justify-content: center; gap: calc(0.25rem * 1.5); text-align: center; vertical-align: middle; outline-offset: 2px; webkit-user-select: none; user-select: none; padding-inline: var(--btn-p); color: var(--btn-fg); --tw-prose-links: var(--btn-fg); height: var(--size); font-size: var(--fontsize, 0.875rem); font-weight: 600; outline-color: var(--btn-color, var(--color-base-content)); transition-property: color, background-color, border-color, box-shadow; transition-timing-function: cubic-bezier(0, 0, 0.2, 1); transition-duration: 0.2s; border-start-start-radius: var(--join-ss, var(--radius-field)); border-start-end-radius: var(--join-se, var(--radius-field)); border-end-start-radius: var(--join-es, var(--radius-field)); border-end-end-radius: var(--join-ee, var(--radius-field)); background-color: var(--btn-bg); background-size: auto, calc(var(--noise) * 100%); background-image: none, var(--btn-noise); border-width: var(--border); border-style: solid; border-color: var(--btn-border); text-shadow: 0 0.5px oklch(100% 0 0 / calc(var(--depth) * 0.15)); box-shadow: 0 0.5px 0 0.5px oklch(100% 0 0 / calc(var(--depth) * 6%)) inset, var(--btn-shadow); --size: calc(var(--size-field, 0.25rem) * 10); --btn-bg: var(--btn-color, var(--color-base-200)); --btn-fg: var(--color-base-content); --btn-p: 1rem; --btn-border: color-mix(in oklab, var(--btn-bg), #000 calc(var(--depth) * 5%)); --btn-shadow: 0 3px 2px -2px color-mix(in oklab, var(--btn-bg) calc(var(--depth) * 30%), #0000), 0 4px 3px -2px color-mix(in oklab, var(--btn-bg) calc(var(--depth) * 30%), #0000); --btn-noise: var(--fx-noise); .prose & { text-decoration-line: none; } @media (hover: hover) { &:hover { --btn-bg: color-mix(in oklab, var(--btn-color, var(--color-base-200)), #000 7%); } } &:focus-visible { outline-width: 2px; outline-style: solid; } &:active:not(.btn-active) { translate: 0 0.5px; --btn-bg: color-mix(in oklab, var(--btn-color, var(--color-base-200)), #000 5%); --btn-border: color-mix(in oklab, var(--btn-color, var(--color-base-200)), #000 7%); --btn-shadow: 0 0 0 0 oklch(0% 0 0/0), 0 0 0 0 oklch(0% 0 0/0); } &:is(:disabled, [disabled], .btn-disabled) { &:not(.btn-link, .btn-ghost) { background-color: color-mix(in oklab, var(--color-base-content) 10%, transparent); box-shadow: none; } pointer-events: none; --btn-border: #0000; --btn-noise: none; --btn-fg: color-mix(in oklch, var(--color-base-content) 20%, #0000); @media (hover: hover) { &:hover { pointer-events: none; background-color: color-mix(in oklab, var(--color-neutral) 20%, transparent); --btn-border: #0000; --btn-fg: color-mix(in oklch, var(--color-base-content) 20%, #0000); } } } &:is(input[type="checkbox"], input[type="radio"]) { appearance: none; &::after { content: attr(aria-label); } } &:where(input:checked:not(.filter .btn)) { --btn-color: var(--color-primary); --btn-fg: var(--color-primary-content); isolation: isolate; } } .list { display: flex; flex-direction: column; font-size: 0.875rem; :where(.list-row) { --list-grid-cols: minmax(0, auto) 1fr; position: relative; display: grid; grid-auto-flow: column; gap: calc(0.25rem * 4); border-radius: var(--radius-box); padding: calc(0.25rem * 4); word-break: break-word; grid-template-columns: var(--list-grid-cols); &:has(.list-col-grow:nth-child(1)) { --list-grid-cols: 1fr; } &:has(.list-col-grow:nth-child(2)) { --list-grid-cols: minmax(0, auto) 1fr; } &:has(.list-col-grow:nth-child(3)) { --list-grid-cols: minmax(0, auto) minmax(0, auto) 1fr; } &:has(.list-col-grow:nth-child(4)) { --list-grid-cols: minmax(0, auto) minmax(0, auto) minmax(0, auto) 1fr; } &:has(.list-col-grow:nth-child(5)) { --list-grid-cols: minmax(0, auto) minmax(0, auto) minmax(0, auto) minmax(0, auto) 1fr; } &:has(.list-col-grow:nth-child(6)) { --list-grid-cols: minmax(0, auto) minmax(0, auto) minmax(0, auto) minmax(0, auto) minmax(0, auto) 1fr; } :not(.list-col-wrap) { grid-row-start: 1; } } & > :not(:last-child) { &.list-row, .list-row { &:after { content: ""; border-bottom: var(--border) solid; inset-inline: var(--radius-box); position: absolute; bottom: calc(0.25rem * 0); border-color: color-mix(in oklab, var(--color-base-content) 5%, transparent); } } } } .toast { position: fixed; inset-inline-start: auto; inset-inline-end: calc(0.25rem * 0); top: auto; bottom: calc(0.25rem * 0); margin: calc(0.25rem * 4); display: flex; min-width: fit-content; flex-direction: column; gap: calc(0.25rem * 2); background-color: transparent; white-space: nowrap; translate: var(--toast-x, 0) var(--toast-y, 0); & > * { animation: toast 0.25s ease-out; } &:where(.toast-start) { inset-inline-start: calc(0.25rem * 0); inset-inline-end: auto; --toast-x: 0; } &:where(.toast-center) { inset-inline-start: calc(1/2 * 100%); inset-inline-end: calc(1/2 * 100%); --toast-x: -50%; } &:where(.toast-end) { inset-inline-start: auto; inset-inline-end: calc(0.25rem * 0); --toast-x: 0; } &:where(.toast-bottom) { top: auto; bottom: calc(0.25rem * 0); --toast-y: 0; } &:where(.toast-middle) { top: calc(1/2 * 100%); bottom: auto; --toast-y: -50%; } &:where(.toast-top) { top: calc(0.25rem * 0); bottom: auto; --toast-y: 0; } } .toggle { border: var(--border) solid currentColor; color: var(--input-color); position: relative; display: inline-grid; flex-shrink: 0; cursor: pointer; appearance: none; place-content: center; vertical-align: middle; webkit-user-select: none; user-select: none; grid-template-columns: 0fr 1fr 1fr; --radius-selector-max: calc( var(--radius-selector) + var(--radius-selector) + var(--radius-selector) ); border-radius: calc( var(--radius-selector) + min(var(--toggle-p), var(--radius-selector-max)) + min(var(--border), var(--radius-selector-max)) ); padding: var(--toggle-p); box-shadow: 0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000) inset; transition: color 0.3s, grid-template-columns 0.2s; --input-color: color-mix(in oklab, var(--color-base-content) 50%, #0000); --toggle-p: 0.1875rem; --size: calc(var(--size-selector, 0.25rem) * 6); width: calc((var(--size) * 2) - (var(--border) + var(--toggle-p)) * 2); height: var(--size); > * { z-index: 1; grid-column: span 1 / span 1; grid-column-start: 2; grid-row-start: 1; height: 100%; cursor: pointer; appearance: none; background-color: transparent; padding: calc(0.25rem * 0.5); transition: opacity 0.2s, rotate 0.4s; border: none; &:focus { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } } &:nth-child(2) { color: var(--color-base-100); rotate: 0deg; } &:nth-child(3) { color: var(--color-base-100); opacity: 0%; rotate: -15deg; } } &:has(:checked) { > :nth-child(2) { opacity: 0%; rotate: 15deg; } > :nth-child(3) { opacity: 100%; rotate: 0deg; } } &:before { position: relative; inset-inline-start: calc(0.25rem * 0); grid-column-start: 2; grid-row-start: 1; aspect-ratio: 1 / 1; height: 100%; border-radius: var(--radius-selector); background-color: currentColor; translate: 0; --tw-content: ""; content: var(--tw-content); transition: background-color 0.1s, translate 0.2s, inset-inline-start 0.2s; box-shadow: 0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000); background-size: auto, calc(var(--noise) * 100%); background-image: none, var(--fx-noise); } @media (forced-colors: active) { &:before { outline-style: var(--tw-outline-style); outline-width: 1px; outline-offset: calc(1px * -1); } } @media print { &:before { outline: 0.25rem solid; outline-offset: -1rem; } } &:focus-visible, &:has(:focus-visible) { outline: 2px solid currentColor; outline-offset: 2px; } &:checked, &[aria-checked="true"], &:has(> input:checked) { grid-template-columns: 1fr 1fr 0fr; background-color: var(--color-base-100); --input-color: var(--color-base-content); &:before { background-color: currentColor; } @starting-style { &:before { opacity: 0; } } } &:indeterminate { grid-template-columns: 0.5fr 1fr 0.5fr; } &:disabled { cursor: not-allowed; opacity: 30%; &:before { background-color: transparent; border: var(--border) solid currentColor; } } } .input { cursor: text; border: var(--border) solid #0000; position: relative; display: inline-flex; flex-shrink: 1; appearance: none; align-items: center; gap: calc(0.25rem * 2); background-color: var(--color-base-100); padding-inline: calc(0.25rem * 3); vertical-align: middle; white-space: nowrap; width: clamp(3rem, 20rem, 100%); height: var(--size); font-size: 0.875rem; border-start-start-radius: var(--join-ss, var(--radius-field)); border-start-end-radius: var(--join-se, var(--radius-field)); border-end-start-radius: var(--join-es, var(--radius-field)); border-end-end-radius: var(--join-ee, var(--radius-field)); border-color: var(--input-color); box-shadow: 0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000) inset, 0 -1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset; --size: calc(var(--size-field, 0.25rem) * 10); --input-color: color-mix(in oklab, var(--color-base-content) 20%, #0000); &:where(input) { display: inline-flex; } :where(input) { display: inline-flex; height: 100%; width: 100%; appearance: none; background-color: transparent; border: none; &:focus, &:focus-within { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } } } &:focus, &:focus-within { --input-color: var(--color-base-content); box-shadow: 0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000); outline: 2px solid var(--input-color); outline-offset: 2px; isolation: isolate; } &:has(> input[disabled]), &:is(:disabled, [disabled]) { cursor: not-allowed; border-color: var(--color-base-200); background-color: var(--color-base-200); color: color-mix(in oklab, var(--color-base-content) 40%, transparent); &::placeholder { color: color-mix(in oklab, var(--color-base-content) 20%, transparent); } box-shadow: none; } &:has(> input[disabled]) > input[disabled] { cursor: not-allowed; } &::-webkit-date-and-time-value { text-align: inherit; } &[type="number"] { &::-webkit-inner-spin-button { margin-block: calc(0.25rem * -3); margin-inline-end: calc(0.25rem * -3); } } &::-webkit-calendar-picker-indicator { position: absolute; inset-inline-end: 0.75em; } } .table { font-size: 0.875rem; position: relative; width: 100%; border-radius: var(--radius-box); text-align: left; &:where(:dir(rtl), [dir="rtl"], [dir="rtl"] *) { text-align: right; } tr.row-hover { &, &:nth-child(even) { &:hover { @media (hover: hover) { background-color: var(--color-base-200); } } } } :where(th, td) { padding-inline: calc(0.25rem * 4); padding-block: calc(0.25rem * 3); vertical-align: middle; } :where(thead, tfoot) { white-space: nowrap; color: color-mix(in oklab, var(--color-base-content) 60%, transparent); font-size: 0.875rem; font-weight: 600; } :where(tfoot) { border-top: var(--border) solid color-mix(in oklch, var(--color-base-content) 5%, #0000); } :where(.table-pin-rows thead tr) { position: sticky; top: calc(0.25rem * 0); z-index: 1; background-color: var(--color-base-100); } :where(.table-pin-rows tfoot tr) { position: sticky; bottom: calc(0.25rem * 0); z-index: 1; background-color: var(--color-base-100); } :where(.table-pin-cols tr th) { position: sticky; right: calc(0.25rem * 0); left: calc(0.25rem * 0); background-color: var(--color-base-100); } :where(thead tr, tbody tr:not(:last-child)) { border-bottom: var(--border) solid color-mix(in oklch, var(--color-base-content) 5%, #0000); } } .range { appearance: none; webkit-appearance: none; --range-thumb: var(--color-base-100); --range-thumb-size: calc(var(--size-selector, 0.25rem) * 6); --range-progress: currentColor; --range-fill: 1; --range-p: 0.25rem; --range-bg: color-mix(in oklab, currentColor 10%, #0000); cursor: pointer; overflow: hidden; background-color: transparent; vertical-align: middle; width: clamp(3rem, 20rem, 100%); --radius-selector-max: calc( var(--radius-selector) + var(--radius-selector) + var(--radius-selector) ); border-radius: calc(var(--radius-selector) + min(var(--range-p), var(--radius-selector-max))); border: none; height: var(--range-thumb-size); [dir="rtl"] & { --range-dir: -1; } &:focus { outline: none; } &:focus-visible { outline: 2px solid; outline-offset: 2px; } &::-webkit-slider-runnable-track { width: 100%; background-color: var(--range-bg); border-radius: var(--radius-selector); height: calc(var(--range-thumb-size) * 0.5); } @media (forced-colors: active) { &::-webkit-slider-runnable-track { border: 1px solid; } } @media (forced-colors: active) { &::-moz-range-track { border: 1px solid; } } &::-webkit-slider-thumb { position: relative; box-sizing: border-box; border-radius: calc(var(--radius-selector) + min(var(--range-p), var(--radius-selector-max))); background-color: currentColor; height: var(--range-thumb-size); width: var(--range-thumb-size); border: var(--range-p) solid; appearance: none; webkit-appearance: none; top: 50%; color: var(--range-progress); transform: translateY(-50%); box-shadow: 0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000), 0 0 0 2rem var(--range-thumb) inset, calc((var(--range-dir, 1) * -100rem) - (var(--range-dir, 1) * var(--range-thumb-size) / 2)) 0 0 calc(100rem * var(--range-fill)); } &::-moz-range-track { width: 100%; background-color: var(--range-bg); border-radius: var(--radius-selector); height: calc(var(--range-thumb-size) * 0.5); } &::-moz-range-thumb { position: relative; box-sizing: border-box; border-radius: calc(var(--radius-selector) + min(var(--range-p), var(--radius-selector-max))); background-color: currentColor; height: var(--range-thumb-size); width: var(--range-thumb-size); border: var(--range-p) solid; top: 50%; color: var(--range-progress); box-shadow: 0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px color-mix(in oklab, currentColor calc(var(--depth) * 10%), #0000), 0 0 0 2rem var(--range-thumb) inset, calc((var(--range-dir, 1) * -100rem) - (var(--range-dir, 1) * var(--range-thumb-size) / 2)) 0 0 calc(100rem * var(--range-fill)); } &:disabled { cursor: not-allowed; opacity: 30%; } } .card { position: relative; display: flex; flex-direction: column; border-radius: var(--radius-box); outline-width: 2px; transition: outline 0.2s ease-in-out; outline: 0 solid #0000; outline-offset: 2px; &:focus { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } } &:focus-visible { outline-color: currentColor; } :where(figure:first-child) { overflow: hidden; border-start-start-radius: inherit; border-start-end-radius: inherit; border-end-start-radius: unset; border-end-end-radius: unset; } :where(figure:last-child) { overflow: hidden; border-start-start-radius: unset; border-start-end-radius: unset; border-end-start-radius: inherit; border-end-end-radius: inherit; } &:where(.card-border) { border: var(--border) solid var(--color-base-200); } &:where(.card-dash) { border: var(--border) dashed var(--color-base-200); } &.image-full { display: grid; &:before { position: relative; grid-column-start: 1; grid-row-start: 1; border-radius: var(--radius-box); background-color: var(--color-neutral); opacity: 75%; content: ""; } > * { grid-column-start: 1; grid-row-start: 1; } > .card-body { position: relative; color: var(--color-neutral-content); } :where(figure) { overflow: hidden; border-radius: inherit; } > figure img { height: 100%; object-fit: cover; } } figure { display: flex; align-items: center; justify-content: center; } &:has(> input:is(input[type="checkbox"], input[type="radio"])) { cursor: pointer; user-select: none; } &:has(> :checked) { outline: 2px solid currentColor; } } .sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border-width: 0; } .select { border: var(--border) solid #0000; position: relative; display: inline-flex; flex-shrink: 1; appearance: none; align-items: center; gap: calc(0.25rem * 1.5); background-color: var(--color-base-100); padding-inline-start: calc(0.25rem * 4); padding-inline-end: calc(0.25rem * 7); vertical-align: middle; width: clamp(3rem, 20rem, 100%); height: var(--size); font-size: 0.875rem; border-start-start-radius: var(--join-ss, var(--radius-field)); border-start-end-radius: var(--join-se, var(--radius-field)); border-end-start-radius: var(--join-es, var(--radius-field)); border-end-end-radius: var(--join-ee, var(--radius-field)); background-image: linear-gradient(45deg, #0000 50%, currentColor 50%), linear-gradient(135deg, currentColor 50%, #0000 50%); background-position: calc(100% - 20px) calc(1px + 50%), calc(100% - 16.1px) calc(1px + 50%); background-size: 4px 4px, 4px 4px; background-repeat: no-repeat; text-overflow: ellipsis; box-shadow: 0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000) inset, 0 -1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset; border-color: var(--input-color); --input-color: color-mix(in oklab, var(--color-base-content) 20%, #0000); --size: calc(var(--size-field, 0.25rem) * 10); [dir="rtl"] & { background-position: calc(0% + 12px) calc(1px + 50%), calc(0% + 16px) calc(1px + 50%); } select { margin-inline-start: calc(0.25rem * -4); margin-inline-end: calc(0.25rem * -7); width: calc(100% + 2.75rem); appearance: none; padding-inline-start: calc(0.25rem * 4); padding-inline-end: calc(0.25rem * 7); height: calc(100% - 2px); background: inherit; border-radius: inherit; border-style: none; &:focus, &:focus-within { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } } &:not(:last-child) { margin-inline-end: calc(0.25rem * -5.5); background-image: none; } } &:focus, &:focus-within { --input-color: var(--color-base-content); box-shadow: 0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000); outline: 2px solid var(--input-color); outline-offset: 2px; } &:has(> select[disabled]), &:is(:disabled, [disabled]) { cursor: not-allowed; border-color: var(--color-base-200); background-color: var(--color-base-200); color: color-mix(in oklab, var(--color-base-content) 40%, transparent); &::placeholder { color: color-mix(in oklab, var(--color-base-content) 20%, transparent); } } &:has(> select[disabled]) > select[disabled] { cursor: not-allowed; } } .menu-horizontal { display: inline-flex; flex-direction: row; & > li:not(.menu-title) > details > ul { position: absolute; margin-inline-start: calc(0.25rem * 0); margin-top: calc(0.25rem * 4); padding-block: calc(0.25rem * 2); padding-inline-end: calc(0.25rem * 2); } & > li > details > ul { &:before { content: none; } } :where(& > li:not(.menu-title) > details > ul) { border-radius: var(--radius-box); background-color: var(--color-base-100); box-shadow: 0 1px 3px 0 oklch(0% 0 0/0.1), 0 1px 2px -1px oklch(0% 0 0/0.1); } } .checkbox { border: var(--border) solid var(--input-color, color-mix(in oklab, var(--color-base-content) 20%, #0000)); position: relative; flex-shrink: 0; cursor: pointer; appearance: none; border-radius: var(--radius-selector); padding: calc(0.25rem * 1); vertical-align: middle; color: var(--color-base-content); box-shadow: 0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 0 #0000 inset, 0 0 #0000; transition: background-color 0.2s, box-shadow 0.2s; --size: calc(var(--size-selector, 0.25rem) * 6); width: var(--size); height: var(--size); background-size: auto, calc(var(--noise) * 100%); background-image: none, var(--fx-noise); &:before { --tw-content: ""; content: var(--tw-content); display: block; width: 100%; height: 100%; rotate: 45deg; background-color: currentColor; opacity: 0%; transition: clip-path 0.3s, opacity 0.1s, rotate 0.3s, translate 0.3s; transition-delay: 0.1s; clip-path: polygon(20% 100%, 20% 80%, 50% 80%, 50% 80%, 70% 80%, 70% 100%); box-shadow: 0px 3px 0 0px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset; font-size: 1rem; line-height: 0.75; } &:focus-visible { outline: 2px solid var(--input-color, currentColor); outline-offset: 2px; } &:checked, &[aria-checked="true"] { background-color: var(--input-color, #0000); box-shadow: 0 0 #0000 inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1)); &:before { clip-path: polygon(20% 100%, 20% 80%, 50% 80%, 50% 0%, 70% 0%, 70% 100%); opacity: 100%; } @media (forced-colors: active) { &:before { rotate: 0deg; background-color: transparent; --tw-content: "✔︎"; clip-path: none; } } @media print { &:before { rotate: 0deg; background-color: transparent; --tw-content: "✔︎"; clip-path: none; } } } &:indeterminate { &:before { rotate: 0deg; opacity: 100%; translate: 0 -35%; clip-path: polygon(20% 100%, 20% 80%, 50% 80%, 50% 80%, 80% 80%, 80% 100%); } } &:disabled { cursor: not-allowed; opacity: 20%; } } .radio { position: relative; flex-shrink: 0; cursor: pointer; appearance: none; border-radius: calc(infinity * 1px); padding: calc(0.25rem * 1); vertical-align: middle; border: var(--border) solid var(--input-color, color-mix(in srgb, currentColor 20%, #0000)); box-shadow: 0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset; --size: calc(var(--size-selector, 0.25rem) * 6); width: var(--size); height: var(--size); color: var(--input-color, currentColor); &:before { display: block; width: 100%; height: 100%; border-radius: calc(infinity * 1px); --tw-content: ""; content: var(--tw-content); background-size: auto, calc(var(--noise) * 100%); background-image: none, var(--fx-noise); } &:focus-visible { outline: 2px solid currentColor; } &:checked, &[aria-checked="true"] { animation: radio 0.2s ease-out; border-color: currentColor; background-color: var(--color-base-100); &:before { background-color: currentColor; box-shadow: 0 -1px oklch(0% 0 0 / calc(var(--depth) * 0.1)) inset, 0 8px 0 -4px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset, 0 1px oklch(0% 0 0 / calc(var(--depth) * 0.1)); } @media (forced-colors: active) { &:before { outline-style: var(--tw-outline-style); outline-width: 1px; outline-offset: calc(1px * -1); } } @media print { &:before { outline: 0.25rem solid; outline-offset: -1rem; } } } &:disabled { cursor: not-allowed; opacity: 20%; } } .progress { position: relative; height: calc(0.25rem * 2); width: 100%; appearance: none; overflow: hidden; border-radius: var(--radius-box); background-color: color-mix(in oklab, currentColor 20%, transparent); color: var(--color-base-content); &:indeterminate { background-image: repeating-linear-gradient( 90deg, currentColor -1%, currentColor 10%, #0000 10%, #0000 90% ); background-size: 200%; background-position-x: 15%; animation: progress 5s ease-in-out infinite; @supports (-moz-appearance: none) { &::-moz-progress-bar { background-color: transparent; background-image: repeating-linear-gradient( 90deg, currentColor -1%, currentColor 10%, #0000 10%, #0000 90% ); background-size: 200%; background-position-x: 15%; animation: progress 5s ease-in-out infinite; } } } @supports (-moz-appearance: none) { &::-moz-progress-bar { border-radius: var(--radius-box); background-color: currentColor; } } @supports (-webkit-appearance: none) { &::-webkit-progress-bar { border-radius: var(--radius-box); background-color: transparent; } &::-webkit-progress-value { border-radius: var(--radius-box); background-color: currentColor; } } } .absolute { position: absolute; } .fixed { position: fixed; } .relative { position: relative; } .static { position: static; } .inset-0 { inset: calc(var(--spacing) * 0); } .inset-y-0 { inset-block: calc(var(--spacing) * 0); } .right-0 { right: calc(var(--spacing) * 0); } .left-0 { left: calc(var(--spacing) * 0); } .left-\[40rem\] { left: 40rem; } .textarea { border: var(--border) solid #0000; min-height: calc(0.25rem * 20); flex-shrink: 1; appearance: none; border-radius: var(--radius-field); background-color: var(--color-base-100); padding-block: calc(0.25rem * 2); vertical-align: middle; width: clamp(3rem, 20rem, 100%); padding-inline-start: 0.75rem; padding-inline-end: 0.75rem; font-size: 0.875rem; border-color: var(--input-color); box-shadow: 0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000) inset, 0 -1px oklch(100% 0 0 / calc(var(--depth) * 0.1)) inset; --input-color: color-mix(in oklab, var(--color-base-content) 20%, #0000); textarea { appearance: none; background-color: transparent; border: none; &:focus, &:focus-within { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } } } &:focus, &:focus-within { --input-color: var(--color-base-content); box-shadow: 0 1px color-mix(in oklab, var(--input-color) calc(var(--depth) * 10%), #0000); outline: 2px solid var(--input-color); outline-offset: 2px; isolation: isolate; } &:has(> textarea[disabled]), &:is(:disabled, [disabled]) { cursor: not-allowed; border-color: var(--color-base-200); background-color: var(--color-base-200); color: color-mix(in oklab, var(--color-base-content) 40%, transparent); &::placeholder { color: color-mix(in oklab, var(--color-base-content) 20%, transparent); } box-shadow: none; } &:has(> textarea[disabled]) > textarea[disabled] { cursor: not-allowed; } } .z-0 { z-index: 0; } .z-10 { z-index: 10; } .z-50 { z-index: 50; } .container { width: 100%; @media (width >= 40rem) { max-width: 40rem; } @media (width >= 48rem) { max-width: 48rem; } @media (width >= 64rem) { max-width: 64rem; } @media (width >= 80rem) { max-width: 80rem; } @media (width >= 96rem) { max-width: 96rem; } } .divider { display: flex; height: calc(0.25rem * 4); flex-direction: row; align-items: center; align-self: stretch; white-space: nowrap; margin: var(--divider-m, 1rem 0); &:before, &:after { content: ""; height: calc(0.25rem * 0.5); width: 100%; flex-grow: 1; background-color: color-mix(in oklab, var(--color-base-content) 10%, transparent); } @media print { &:before, &:after { border: 0.5px solid; } } &:not(:empty) { gap: calc(0.25rem * 4); } } .-mx-2 { margin-inline: calc(var(--spacing) * -2); } .mx-auto { margin-inline: auto; } .-my-0\.5 { margin-block: calc(var(--spacing) * -0.5); } .label { display: inline-flex; align-items: center; gap: calc(0.25rem * 1.5); white-space: nowrap; color: color-mix(in oklab, currentColor 60%, transparent); &:has(input) { cursor: pointer; } &:is(.input > *, .select > *) { display: flex; height: calc(100% - 0.5rem); align-items: center; padding-inline: calc(0.25rem * 3); white-space: nowrap; font-size: inherit; &:first-child { margin-inline-start: calc(0.25rem * -3); margin-inline-end: calc(0.25rem * 3); border-inline-end: var(--border) solid color-mix(in oklab, currentColor 10%, #0000); } &:last-child { margin-inline-start: calc(0.25rem * 3); margin-inline-end: calc(0.25rem * -3); border-inline-start: var(--border) solid color-mix(in oklab, currentColor 10%, #0000); } } } .mt-1\.5 { margin-top: calc(var(--spacing) * 1.5); } .mt-4 { margin-top: calc(var(--spacing) * 4); } .mt-8 { margin-top: calc(var(--spacing) * 8); } .mt-10 { margin-top: calc(var(--spacing) * 10); } .mb-1 { margin-bottom: calc(var(--spacing) * 1); } .mb-2 { margin-bottom: calc(var(--spacing) * 2); } .ml-1 { margin-left: calc(var(--spacing) * 1); } .ml-3 { margin-left: calc(var(--spacing) * 3); } .status { display: inline-block; aspect-ratio: 1 / 1; width: calc(0.25rem * 2); height: calc(0.25rem * 2); border-radius: var(--radius-selector); background-color: color-mix(in oklab, var(--color-base-content) 20%, transparent); background-position: center; background-repeat: no-repeat; vertical-align: middle; color: color-mix(in oklab, var(--color-black) 30%, transparent); background-image: radial-gradient( circle at 35% 30%, oklch(1 0 0 / calc(var(--depth) * 0.5)), #0000 ); box-shadow: 0 2px 3px -1px color-mix(in oklab, currentColor calc(var(--depth) * 100%), #0000); } .badge { display: inline-flex; align-items: center; justify-content: center; gap: calc(0.25rem * 2); border-radius: var(--radius-selector); vertical-align: middle; color: var(--badge-fg); border: var(--border) solid var(--badge-color, var(--color-base-200)); font-size: 0.875rem; width: fit-content; padding-inline: calc(0.25rem * 3 - var(--border)); background-size: auto, calc(var(--noise) * 100%); background-image: none, var(--fx-noise); background-color: var(--badge-bg); --badge-bg: var(--badge-color, var(--color-base-100)); --badge-fg: var(--color-base-content); --size: calc(var(--size-selector, 0.25rem) * 6); height: var(--size); &.badge-outline { --badge-fg: var(--badge-color); --badge-bg: #0000; background-image: none; } &.badge-dash { --badge-fg: var(--badge-color); --badge-bg: #0000; border-style: dashed; background-image: none; } &.badge-soft { color: var(--badge-color, var(--color-base-content)); background-color: color-mix( in oklab, var(--badge-color, var(--color-base-content)) 8%, var(--color-base-100) ); border-color: color-mix( in oklab, var(--badge-color, var(--color-base-content)) 10%, var(--color-base-100) ); background-image: none; } } .hero-arrow-left { --hero-arrow-left: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20viewBox%3D%220%200%2024%2024%22%20stroke-width%3D%221.5%22%20stroke%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20d%3D%22M10.5%2019.5%203%2012m0%200%207.5-7.5M3%2012h18%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-arrow-left); mask: var(--hero-arrow-left); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1.5rem; height: 1.5rem; } .hero-arrow-path { --hero-arrow-path: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20viewBox%3D%220%200%2024%2024%22%20stroke-width%3D%221.5%22%20stroke%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20d%3D%22M16.023%209.348h4.992v-.001M2.985%2019.644v-4.992m0%200h4.992m-4.993%200%203.181%203.183a8.25%208.25%200%200%200%2013.803-3.7M4.031%209.865a8.25%208.25%200%200%201%2013.803-3.7l3.181%203.182m0-4.991v4.99%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-arrow-path); mask: var(--hero-arrow-path); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1.5rem; height: 1.5rem; } .hero-computer-desktop-micro { --hero-computer-desktop-micro: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2016%2016%22%20fill%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20fill-rule%3D%22evenodd%22%20d%3D%22M2%204.25A2.25%202.25%200%200%201%204.25%202h7.5A2.25%202.25%200%200%201%2014%204.25v5.5A2.25%202.25%200%200%201%2011.75%2012h-1.312c.1.128.21.248.328.36a.75.75%200%200%201%20.234.545v.345a.75.75%200%200%201-.75.75h-4.5a.75.75%200%200%201-.75-.75v-.345a.75.75%200%200%201%20.234-.545c.118-.111.228-.232.328-.36H4.25A2.25%202.25%200%200%201%202%209.75v-5.5Zm2.25-.75a.75.75%200%200%200-.75.75v4.5c0%20.414.336.75.75.75h7.5a.75.75%200%200%200%20.75-.75v-4.5a.75.75%200%200%200-.75-.75h-7.5Z%22%20clip-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-computer-desktop-micro); mask: var(--hero-computer-desktop-micro); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1rem; height: 1rem; } .hero-exclamation-circle { --hero-exclamation-circle: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2020%2020%22%20fill%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20fill-rule%3D%22evenodd%22%20d%3D%22M18%2010a8%208%200%201%201-16%200%208%208%200%200%201%2016%200Zm-8-5a.75.75%200%200%201%20.75.75v4.5a.75.75%200%200%201-1.5%200v-4.5A.75.75%200%200%201%2010%205Zm0%2010a1%201%200%201%200%200-2%201%201%200%200%200%200%202Z%22%20clip-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-exclamation-circle); mask: var(--hero-exclamation-circle); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1.25rem; height: 1.25rem; } .hero-information-circle { --hero-information-circle: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2020%2020%22%20fill%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20fill-rule%3D%22evenodd%22%20d%3D%22M18%2010a8%208%200%201%201-16%200%208%208%200%200%201%2016%200Zm-7-4a1%201%200%201%201-2%200%201%201%200%200%201%202%200ZM9%209a.75.75%200%200%200%200%201.5h.253a.25.25%200%200%201%20.244.304l-.459%202.066A1.75%201.75%200%200%200%2010.747%2015H11a.75.75%200%200%200%200-1.5h-.253a.25.25%200%200%201-.244-.304l.459-2.066A1.75%201.75%200%200%200%209.253%209H9Z%22%20clip-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-information-circle); mask: var(--hero-information-circle); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1.25rem; height: 1.25rem; } .hero-moon-micro { --hero-moon-micro: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2016%2016%22%20fill%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20d%3D%22M14.438%2010.148c.19-.425-.321-.787-.748-.601A5.5%205.5%200%200%201%206.453%202.31c.186-.427-.176-.938-.6-.748a6.501%206.501%200%201%200%208.585%208.586Z%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-moon-micro); mask: var(--hero-moon-micro); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1rem; height: 1rem; } .hero-pencil-square { --hero-pencil-square: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20viewBox%3D%220%200%2024%2024%22%20stroke-width%3D%221.5%22%20stroke%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20d%3D%22m16.862%204.487%201.687-1.688a1.875%201.875%200%201%201%202.652%202.652L10.582%2016.07a4.5%204.5%200%200%201-1.897%201.13L6%2018l.8-2.685a4.5%204.5%200%200%201%201.13-1.897l8.932-8.931Zm0%200L19.5%207.125M18%2014v4.75A2.25%202.25%200%200%201%2015.75%2021H5.25A2.25%202.25%200%200%201%203%2018.75V8.25A2.25%202.25%200%200%201%205.25%206H10%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-pencil-square); mask: var(--hero-pencil-square); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1.5rem; height: 1.5rem; } .hero-plus { --hero-plus: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20viewBox%3D%220%200%2024%2024%22%20stroke-width%3D%221.5%22%20stroke%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20d%3D%22M12%204.5v15m7.5-7.5h-15%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-plus); mask: var(--hero-plus); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1.5rem; height: 1.5rem; } .hero-sun-micro { --hero-sun-micro: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2016%2016%22%20fill%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20d%3D%22M8%201a.75.75%200%200%201%20.75.75v1.5a.75.75%200%200%201-1.5%200v-1.5A.75.75%200%200%201%208%201ZM10.5%208a2.5%202.5%200%201%201-5%200%202.5%202.5%200%200%201%205%200ZM12.95%204.11a.75.75%200%201%200-1.06-1.06l-1.062%201.06a.75.75%200%200%200%201.061%201.062l1.06-1.061ZM15%208a.75.75%200%200%201-.75.75h-1.5a.75.75%200%200%201%200-1.5h1.5A.75.75%200%200%201%2015%208ZM11.89%2012.95a.75.75%200%200%200%201.06-1.06l-1.06-1.062a.75.75%200%200%200-1.062%201.061l1.061%201.06ZM8%2012a.75.75%200%200%201%20.75.75v1.5a.75.75%200%200%201-1.5%200v-1.5A.75.75%200%200%201%208%2012ZM5.172%2011.89a.75.75%200%200%200-1.061-1.062L3.05%2011.89a.75.75%200%201%200%201.06%201.06l1.06-1.06ZM4%208a.75.75%200%200%201-.75.75h-1.5a.75.75%200%200%201%200-1.5h1.5A.75.75%200%200%201%204%208ZM4.11%205.172A.75.75%200%200%200%205.173%204.11L4.11%203.05a.75.75%200%201%200-1.06%201.06l1.06%201.06Z%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-sun-micro); mask: var(--hero-sun-micro); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1rem; height: 1rem; } .hero-x-mark { --hero-x-mark: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22currentColor%22%20aria-hidden%3D%22true%22%20data-slot%3D%22icon%22%3E%20%20%3Cpath%20fill-rule%3D%22evenodd%22%20d%3D%22M5.47%205.47a.75.75%200%200%201%201.06%200L12%2010.94l5.47-5.47a.75.75%200%201%201%201.06%201.06L13.06%2012l5.47%205.47a.75.75%200%201%201-1.06%201.06L12%2013.06l-5.47%205.47a.75.75%200%200%201-1.06-1.06L10.94%2012%205.47%206.53a.75.75%200%200%201%200-1.06Z%22%20clip-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E'); -webkit-mask: var(--hero-x-mark); mask: var(--hero-x-mark); mask-repeat: no-repeat; background-color: currentColor; vertical-align: middle; display: inline-block; width: 1.5rem; height: 1.5rem; } .navbar { display: flex; width: 100%; align-items: center; padding: 0.5rem; min-height: 4rem; } .footer { display: grid; width: 100%; grid-auto-flow: row; place-items: start; column-gap: calc(0.25rem * 4); row-gap: calc(0.25rem * 10); font-size: 0.875rem; line-height: 1.25rem; & > * { display: grid; place-items: start; gap: calc(0.25rem * 2); } &.footer-center { grid-auto-flow: column dense; place-items: center; text-align: center; & > * { place-items: center; } } } .fieldset-label { display: flex; align-items: center; gap: calc(0.25rem * 1.5); color: color-mix(in oklab, var(--color-base-content) 60%, transparent); &:has(input) { cursor: pointer; } } .alert { display: grid; align-items: center; gap: calc(0.25rem * 4); border-radius: var(--radius-box); padding-inline: calc(0.25rem * 4); padding-block: calc(0.25rem * 3); color: var(--color-base-content); background-color: var(--alert-color, var(--color-base-200)); justify-content: start; justify-items: start; grid-auto-flow: column; grid-template-columns: auto; text-align: start; border: var(--border) solid var(--color-base-200); font-size: 0.875rem; line-height: 1.25rem; background-size: auto, calc(var(--noise) * 100%); background-image: none, var(--fx-noise); box-shadow: 0 3px 0 -2px oklch(100% 0 0 / calc(var(--depth) * 0.08)) inset, 0 1px color-mix( in oklab, color-mix(in oklab, #000 20%, var(--alert-color, var(--color-base-200))) calc(var(--depth) * 20%), #0000 ), 0 4px 3px -2px oklch(0% 0 0 / calc(var(--depth) * 0.08)); &:has(:nth-child(2)) { grid-template-columns: auto minmax(auto, 1fr); } &.alert-outline { background-color: transparent; color: var(--alert-color); box-shadow: none; background-image: none; } &.alert-dash { background-color: transparent; color: var(--alert-color); border-style: dashed; box-shadow: none; background-image: none; } &.alert-soft { color: var(--alert-color, var(--color-base-content)); background: color-mix( in oklab, var(--alert-color, var(--color-base-content)) 8%, var(--color-base-100) ); border-color: color-mix( in oklab, var(--alert-color, var(--color-base-content)) 10%, var(--color-base-100) ); box-shadow: none; background-image: none; } } .fieldset { display: grid; gap: calc(0.25rem * 1.5); padding-block: calc(0.25rem * 1); font-size: 0.75rem; grid-template-columns: 1fr; grid-auto-rows: max-content; } .block { display: block; } .contents { display: contents; } .flex { display: flex; } .grid { display: grid; } .hidden { display: none; } .inline-flex { display: inline-flex; } .table { display: table; } .size-3 { width: calc(var(--spacing) * 3); height: calc(var(--spacing) * 3); } .size-4 { width: calc(var(--spacing) * 4); height: calc(var(--spacing) * 4); } .size-5 { width: calc(var(--spacing) * 5); height: calc(var(--spacing) * 5); } .h-3 { height: calc(var(--spacing) * 3); } .h-4 { height: calc(var(--spacing) * 4); } .h-6 { height: calc(var(--spacing) * 6); } .h-12 { height: calc(var(--spacing) * 12); } .h-full { height: 100%; } .w-0 { width: calc(var(--spacing) * 0); } .w-3 { width: calc(var(--spacing) * 3); } .w-4 { width: calc(var(--spacing) * 4); } .w-6 { width: calc(var(--spacing) * 6); } .w-80 { width: calc(var(--spacing) * 80); } .w-\[33\%\] { width: 33%; } .w-full { width: 100%; } .max-w-2xl { max-width: var(--container-2xl); } .max-w-80 { max-width: calc(var(--spacing) * 80); } .max-w-sm { max-width: var(--container-sm); } .max-w-xl { max-width: var(--container-xl); } .flex-1 { flex: 1; } .flex-none { flex: none; } .shrink-0 { flex-shrink: 0; } .translate-y-0 { --tw-translate-y: calc(var(--spacing) * 0); translate: var(--tw-translate-x) var(--tw-translate-y); } .translate-y-4 { --tw-translate-y: calc(var(--spacing) * 4); translate: var(--tw-translate-x) var(--tw-translate-y); } .skeleton { border-radius: var(--radius-box); background-color: var(--color-base-300); @media (prefers-reduced-motion: reduce) { transition-duration: 15s; } will-change: background-position; animation: skeleton 1.8s ease-in-out infinite; background-image: linear-gradient( 105deg, #0000 0% 40%, var(--color-base-100) 50%, #0000 60% 100% ); background-size: 200% auto; background-repeat: no-repeat; background-position-x: -50%; } .link { cursor: pointer; text-decoration-line: underline; &:focus { --tw-outline-style: none; outline-style: none; @media (forced-colors: active) { outline: 2px solid transparent; outline-offset: 2px; } } &:focus-visible { outline: 2px solid currentColor; outline-offset: 2px; } } .cursor-pointer { cursor: pointer; } .grid-cols-1 { grid-template-columns: repeat(1, minmax(0, 1fr)); } .flex-row { flex-direction: row; } .items-center { align-items: center; } .justify-between { justify-content: space-between; } .justify-end { justify-content: flex-end; } .gap-2 { gap: calc(var(--spacing) * 2); } .gap-3 { gap: calc(var(--spacing) * 3); } .gap-4 { gap: calc(var(--spacing) * 4); } .gap-6 { gap: calc(var(--spacing) * 6); } .space-y-4 { :where(& > :not(:last-child)) { --tw-space-y-reverse: 0; margin-block-start: calc(calc(var(--spacing) * 4) * var(--tw-space-y-reverse)); margin-block-end: calc(calc(var(--spacing) * 4) * calc(1 - var(--tw-space-y-reverse))); } } .gap-x-6 { column-gap: calc(var(--spacing) * 6); } .space-x-4 { :where(& > :not(:last-child)) { --tw-space-x-reverse: 0; margin-inline-start: calc(calc(var(--spacing) * 4) * var(--tw-space-x-reverse)); margin-inline-end: calc(calc(var(--spacing) * 4) * calc(1 - var(--tw-space-x-reverse))); } } .gap-y-4 { row-gap: calc(var(--spacing) * 4); } .self-start { align-self: flex-start; } .rounded-box { border-radius: var(--radius-box); } .rounded-box { border-radius: var(--radius-box); } .rounded-full { border-radius: calc(infinity * 1px); } .rounded-lg { border-radius: var(--radius-lg); } .border-1 { border-style: var(--tw-border-style); border-width: 1px; } .border-2 { border-style: var(--tw-border-style); border-width: 2px; } .alert-error { border-color: var(--color-error); color: var(--color-error-content); --alert-color: var(--color-error); } .alert-info { border-color: var(--color-info); color: var(--color-info-content); --alert-color: var(--color-info); } .border-base-200 { border-color: var(--color-base-200); } .border-base-300 { border-color: var(--color-base-300); } .table-zebra { tbody { tr { &:nth-child(even) { background-color: var(--color-base-200); :where(.table-pin-cols tr th) { background-color: var(--color-base-200); } } &.row-hover { &, &:nth-child(even) { &:hover { @media (hover: hover) { background-color: var(--color-base-300); } } } } } } } .bg-base-100 { background-color: var(--color-base-100); } .bg-base-200 { background-color: var(--color-base-200); } .bg-base-300 { background-color: var(--color-base-300); } .fill-base-content\/40 { fill: color-mix(in oklab, var(--color-base-content) 40%, transparent); } .checkbox-sm { padding: 0.1875rem; --size: calc(var(--size-selector, 0.25rem) * 5); } .p-2 { padding: calc(var(--spacing) * 2); } .badge-sm { --size: calc(var(--size-selector, 0.25rem) * 5); font-size: 0.75rem; padding-inline: calc(0.25rem * 2.5 - var(--border)); } .px-1 { padding-inline: calc(var(--spacing) * 1); } .px-2 { padding-inline: calc(var(--spacing) * 2); } .px-4 { padding-inline: calc(var(--spacing) * 4); } .px-6 { padding-inline: calc(var(--spacing) * 6); } .py-0\.5 { padding-block: calc(var(--spacing) * 0.5); } .py-4 { padding-block: calc(var(--spacing) * 4); } .py-10 { padding-block: calc(var(--spacing) * 10); } .py-20 { padding-block: calc(var(--spacing) * 20); } .pb-4 { padding-bottom: calc(var(--spacing) * 4); } .text-center { text-align: center; } .text-lg { font-size: var(--text-lg); line-height: var(--tw-leading, var(--text-lg--line-height)); } .text-sm { font-size: var(--text-sm); line-height: var(--tw-leading, var(--text-sm--line-height)); } .text-\[2rem\] { font-size: 2rem; } .leading-6 { --tw-leading: calc(var(--spacing) * 6); line-height: calc(var(--spacing) * 6); } .leading-7 { --tw-leading: calc(var(--spacing) * 7); line-height: calc(var(--spacing) * 7); } .leading-8 { --tw-leading: calc(var(--spacing) * 8); line-height: calc(var(--spacing) * 8); } .leading-10 { --tw-leading: calc(var(--spacing) * 10); line-height: calc(var(--spacing) * 10); } .font-bold { --tw-font-weight: var(--font-weight-bold); font-weight: var(--font-weight-bold); } .font-semibold { --tw-font-weight: var(--font-weight-semibold); font-weight: var(--font-weight-semibold); } .tracking-tighter { --tw-tracking: var(--tracking-tighter); letter-spacing: var(--tracking-tighter); } .text-balance { text-wrap: balance; } .text-wrap { text-wrap: wrap; } .text-base-content\/70 { color: color-mix(in oklab, var(--color-base-content) 70%, transparent); } .text-base-content\/80 { color: color-mix(in oklab, var(--color-base-content) 80%, transparent); } .text-error { color: var(--color-error); } .underline { text-decoration-line: underline; } .opacity-0 { opacity: 0%; } .opacity-40 { opacity: 40%; } .opacity-75 { opacity: 75%; } .opacity-100 { opacity: 100%; } .outline { outline-style: var(--tw-outline-style); outline-width: 1px; } .btn-ghost { &:not(.btn-active, :hover, :active:focus, :focus-visible) { --btn-shadow: ""; --btn-bg: #0000; --btn-border: #0000; --btn-noise: none; &:not(:disabled, [disabled], .btn-disabled) { outline-color: currentColor; --btn-fg: currentColor; } } } .brightness-200 { --tw-brightness: brightness(200%); filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,); } .transition { transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, --tw-gradient-from, --tw-gradient-via, --tw-gradient-to, opacity, box-shadow, transform, translate, scale, rotate, filter, -webkit-backdrop-filter, backdrop-filter; transition-timing-function: var(--tw-ease, var(--default-transition-timing-function)); transition-duration: var(--tw-duration, var(--default-transition-duration)); } .transition-\[left\] { transition-property: left; transition-timing-function: var(--tw-ease, var(--default-transition-timing-function)); transition-duration: var(--tw-duration, var(--default-transition-duration)); } .transition-all { transition-property: all; transition-timing-function: var(--tw-ease, var(--default-transition-timing-function)); transition-duration: var(--tw-duration, var(--default-transition-duration)); } .duration-200 { --tw-duration: 200ms; transition-duration: 200ms; } .duration-300 { --tw-duration: 300ms; transition-duration: 300ms; } .ease-in { --tw-ease: var(--ease-in); transition-timing-function: var(--ease-in); } .ease-out { --tw-ease: var(--ease-out); transition-timing-function: var(--ease-out); } .btn-soft { &:not(.btn-active, :hover, :active:focus, :focus-visible, :disabled, [disabled], .btn-disabled) { --btn-shadow: ""; --btn-fg: var(--btn-color, var(--color-base-content)); --btn-bg: color-mix( in oklab, var(--btn-color, var(--color-base-content)) 8%, var(--color-base-100) ); --btn-border: color-mix( in oklab, var(--btn-color, var(--color-base-content)) 10%, var(--color-base-100) ); --btn-noise: none; } } .badge-warning { --badge-color: var(--color-warning); --badge-fg: var(--color-warning-content); } .btn-primary { --btn-color: var(--color-primary); --btn-fg: var(--color-primary-content); } .input-error { &, &:focus, &:focus-within { --input-color: var(--color-error); } } .select-error { &, &:focus, &:focus-within { --input-color: var(--color-error); } } .textarea-error { &, &:focus, &:focus-within { --input-color: var(--color-error); } } .group-hover\:bg-base-300 { &:is(:where(.group):hover *) { @media (hover: hover) { background-color: var(--color-base-300); } } } .group-hover\:fill-base-content { &:is(:where(.group):hover *) { @media (hover: hover) { fill: var(--color-base-content); } } } .group-hover\:opacity-70 { &:is(:where(.group):hover *) { @media (hover: hover) { opacity: 70%; } } } .hover\:cursor-pointer { &:hover { @media (hover: hover) { cursor: pointer; } } } .hover\:bg-base-200 { &:hover { @media (hover: hover) { background-color: var(--color-base-200); } } } .hover\:text-base-content { &:hover { @media (hover: hover) { color: var(--color-base-content); } } } .hover\:underline { &:hover { @media (hover: hover) { text-decoration-line: underline; } } } .hover\:opacity-100 { &:hover { @media (hover: hover) { opacity: 100%; } } } .motion-safe\:animate-spin { @media (prefers-reduced-motion: no-preference) { animation: var(--animate-spin); } } .sm\:w-96 { @media (width >= 40rem) { width: calc(var(--spacing) * 96); } } .sm\:w-auto { @media (width >= 40rem) { width: auto; } } .sm\:max-w-96 { @media (width >= 40rem) { max-width: calc(var(--spacing) * 96); } } .sm\:translate-y-0 { @media (width >= 40rem) { --tw-translate-y: calc(var(--spacing) * 0); translate: var(--tw-translate-x) var(--tw-translate-y); } } .sm\:scale-95 { @media (width >= 40rem) { --tw-scale-x: 95%; --tw-scale-y: 95%; --tw-scale-z: 95%; scale: var(--tw-scale-x) var(--tw-scale-y); } } .sm\:scale-100 { @media (width >= 40rem) { --tw-scale-x: 100%; --tw-scale-y: 100%; --tw-scale-z: 100%; scale: var(--tw-scale-x) var(--tw-scale-y); } } .sm\:grid-cols-2 { @media (width >= 40rem) { grid-template-columns: repeat(2, minmax(0, 1fr)); } } .sm\:grid-cols-3 { @media (width >= 40rem) { grid-template-columns: repeat(3, minmax(0, 1fr)); } } .sm\:flex-col { @media (width >= 40rem) { flex-direction: column; } } .sm\:px-6 { @media (width >= 40rem) { padding-inline: calc(var(--spacing) * 6); } } .sm\:py-6 { @media (width >= 40rem) { padding-block: calc(var(--spacing) * 6); } } .sm\:py-28 { @media (width >= 40rem) { padding-block: calc(var(--spacing) * 28); } } .sm\:group-hover\:scale-105 { @media (width >= 40rem) { &:is(:where(.group):hover *) { @media (hover: hover) { --tw-scale-x: 105%; --tw-scale-y: 105%; --tw-scale-z: 105%; scale: var(--tw-scale-x) var(--tw-scale-y); } } } } .lg\:mx-0 { @media (width >= 64rem) { margin-inline: calc(var(--spacing) * 0); } } .lg\:block { @media (width >= 64rem) { display: block; } } .lg\:px-8 { @media (width >= 64rem) { padding-inline: calc(var(--spacing) * 8); } } .xl\:left-\[50rem\] { @media (width >= 80rem) { left: 50rem; } } .xl\:px-28 { @media (width >= 80rem) { padding-inline: calc(var(--spacing) * 28); } } .xl\:py-32 { @media (width >= 80rem) { padding-block: calc(var(--spacing) * 32); } } .\[\[data-theme\=dark\]_\&\]\:left-\[66\%\] { [data-theme=dark] & { left: 66%; } } .\[\[data-theme\=light\]_\&\]\:left-\[33\%\] { [data-theme=light] & { left: 33%; } } } [data-phx-session] { display: contents; } @layer base { @property --radialprogress { syntax: ""; inherits: true; initial-value: 0%; } } @layer base { :root { scrollbar-color: color-mix(in oklch, currentColor 35%, #0000) #0000; } } @layer base { :root:has( .modal-open, .modal[open], .modal:target, .modal-toggle:checked, .drawer:not([class*="drawer-open"]) > .drawer-toggle:checked ) { overflow: hidden; } } @layer base { :root, [data-theme] { background-color: var(--root-bg, var(--color-base-100)); color: var(--color-base-content); } } @layer base { :root { --fx-noise: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='a'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='1.34' numOctaves='4' stitchTiles='stitch'%3E%3C/feTurbulence%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23a)' opacity='0.2'%3E%3C/rect%3E%3C/svg%3E"); } .chat { --mask-chat: url("data:image/svg+xml,%3csvg width='13' height='13' xmlns='http://www.w3.org/2000/svg'%3e%3cpath fill='black' d='M0 11.5004C0 13.0004 2 13.0004 2 13.0004H12H13V0.00036329L12.5 0C12.5 0 11.977 2.09572 11.8581 2.50033C11.6075 3.35237 10.9149 4.22374 9 5.50036C6 7.50036 0 10.0004 0 11.5004Z'/%3e%3c/svg%3e"); } } @layer base { :where( :root:has( .modal-open, .modal[open], .modal:target, .modal-toggle:checked, .drawer:not(.drawer-open) > .drawer-toggle:checked ) ) { scrollbar-gutter: stable; background-image: linear-gradient(var(--color-base-100), var(--color-base-100)); --root-bg: color-mix(in srgb, var(--color-base-100), oklch(0% 0 0) 40%); } } @keyframes skeleton { 0% { background-position: 150%; } 100% { background-position: -50%; } } @keyframes progress { 50% { background-position-x: -115%; } } @keyframes radio { 0% { padding: 5px; } 50% { padding: 3px; } } @keyframes dropdown { 0% { opacity: 0; } } @keyframes rating { 0%, 40% { scale: 1.1; filter: brightness(1.05) contrast(1.05); } } @keyframes toast { 0% { scale: 0.9; opacity: 0; } 100% { scale: 1; opacity: 1; } } @layer base { @media (prefers-color-scheme: dark) { :root { color-scheme: dark; --color-base-100: oklch(30.33% 0.016 252.42); --color-base-200: oklch(25.26% 0.014 253.1); --color-base-300: oklch(20.15% 0.012 254.09); --color-base-content: oklch(97.807% 0.029 256.847); --color-primary: oklch(58% 0.233 277.117); --color-primary-content: oklch(96% 0.018 272.314); --color-secondary: oklch(58% 0.233 277.117); --color-secondary-content: oklch(96% 0.018 272.314); --color-accent: oklch(60% 0.25 292.717); --color-accent-content: oklch(96% 0.016 293.756); --color-neutral: oklch(37% 0.044 257.287); --color-neutral-content: oklch(98% 0.003 247.858); --color-info: oklch(58% 0.158 241.966); --color-info-content: oklch(97% 0.013 236.62); --color-success: oklch(60% 0.118 184.704); --color-success-content: oklch(98% 0.014 180.72); --color-warning: oklch(66% 0.179 58.318); --color-warning-content: oklch(98% 0.022 95.277); --color-error: oklch(58% 0.253 17.585); --color-error-content: oklch(96% 0.015 12.422); --radius-selector: 0.25rem; --radius-field: 0.25rem; --radius-box: 0.5rem; --size-selector: 0.21875rem; --size-field: 0.21875rem; --border: 1.5px; --depth: 1; --noise: 0; } } } @layer base { :root:has(input.theme-controller[value=dark]:checked),[data-theme="dark"] { color-scheme: dark; --color-base-100: oklch(30.33% 0.016 252.42); --color-base-200: oklch(25.26% 0.014 253.1); --color-base-300: oklch(20.15% 0.012 254.09); --color-base-content: oklch(97.807% 0.029 256.847); --color-primary: oklch(58% 0.233 277.117); --color-primary-content: oklch(96% 0.018 272.314); --color-secondary: oklch(58% 0.233 277.117); --color-secondary-content: oklch(96% 0.018 272.314); --color-accent: oklch(60% 0.25 292.717); --color-accent-content: oklch(96% 0.016 293.756); --color-neutral: oklch(37% 0.044 257.287); --color-neutral-content: oklch(98% 0.003 247.858); --color-info: oklch(58% 0.158 241.966); --color-info-content: oklch(97% 0.013 236.62); --color-success: oklch(60% 0.118 184.704); --color-success-content: oklch(98% 0.014 180.72); --color-warning: oklch(66% 0.179 58.318); --color-warning-content: oklch(98% 0.022 95.277); --color-error: oklch(58% 0.253 17.585); --color-error-content: oklch(96% 0.015 12.422); --radius-selector: 0.25rem; --radius-field: 0.25rem; --radius-box: 0.5rem; --size-selector: 0.21875rem; --size-field: 0.21875rem; --border: 1.5px; --depth: 1; --noise: 0; } } @layer base { :where(:root),:root:has(input.theme-controller[value=light]:checked),[data-theme="light"] { color-scheme: light; --color-base-100: oklch(98% 0 0); --color-base-200: oklch(96% 0.001 286.375); --color-base-300: oklch(92% 0.004 286.32); --color-base-content: oklch(21% 0.006 285.885); --color-primary: oklch(70% 0.213 47.604); --color-primary-content: oklch(98% 0.016 73.684); --color-secondary: oklch(55% 0.027 264.364); --color-secondary-content: oklch(98% 0.002 247.839); --color-accent: oklch(0% 0 0); --color-accent-content: oklch(100% 0 0); --color-neutral: oklch(44% 0.017 285.786); --color-neutral-content: oklch(98% 0 0); --color-info: oklch(62% 0.214 259.815); --color-info-content: oklch(97% 0.014 254.604); --color-success: oklch(70% 0.14 182.503); --color-success-content: oklch(98% 0.014 180.72); --color-warning: oklch(66% 0.179 58.318); --color-warning-content: oklch(98% 0.022 95.277); --color-error: oklch(58% 0.253 17.585); --color-error-content: oklch(96% 0.015 12.422); --radius-selector: 0.25rem; --radius-field: 0.25rem; --radius-box: 0.5rem; --size-selector: 0.21875rem; --size-field: 0.21875rem; --border: 1.5px; --depth: 1; --noise: 0; } } @property --tw-translate-x { syntax: "*"; inherits: false; initial-value: 0; } @property --tw-translate-y { syntax: "*"; inherits: false; initial-value: 0; } @property --tw-translate-z { syntax: "*"; inherits: false; initial-value: 0; } @property --tw-space-y-reverse { syntax: "*"; inherits: false; initial-value: 0; } @property --tw-space-x-reverse { syntax: "*"; inherits: false; initial-value: 0; } @property --tw-border-style { syntax: "*"; inherits: false; initial-value: solid; } @property --tw-leading { syntax: "*"; inherits: false; } @property --tw-font-weight { syntax: "*"; inherits: false; } @property --tw-tracking { syntax: "*"; inherits: false; } @property --tw-outline-style { syntax: "*"; inherits: false; initial-value: solid; } @property --tw-blur { syntax: "*"; inherits: false; } @property --tw-brightness { syntax: "*"; inherits: false; } @property --tw-contrast { syntax: "*"; inherits: false; } @property --tw-grayscale { syntax: "*"; inherits: false; } @property --tw-hue-rotate { syntax: "*"; inherits: false; } @property --tw-invert { syntax: "*"; inherits: false; } @property --tw-opacity { syntax: "*"; inherits: false; } @property --tw-saturate { syntax: "*"; inherits: false; } @property --tw-sepia { syntax: "*"; inherits: false; } @property --tw-drop-shadow { syntax: "*"; inherits: false; } @property --tw-duration { syntax: "*"; inherits: false; } @property --tw-ease { syntax: "*"; inherits: false; } @property --tw-scale-x { syntax: "*"; inherits: false; initial-value: 1; } @property --tw-scale-y { syntax: "*"; inherits: false; initial-value: 1; } @property --tw-scale-z { syntax: "*"; inherits: false; initial-value: 1; } @keyframes spin { to { transform: rotate(360deg); } } ================================================ FILE: installer/templates/phx_static/robots.txt ================================================ # 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: / ================================================ FILE: installer/templates/phx_test/controllers/error_html_test.exs.eex ================================================ defmodule <%= @web_namespace %>.ErrorHTMLTest do use <%= @web_namespace %>.ConnCase, async: true # Bring render_to_string/4 for testing custom views import Phoenix.Template, only: [render_to_string: 4] test "renders 404.html" do assert render_to_string(<%= @web_namespace %>.ErrorHTML, "404", "html", []) == "Not Found" end test "renders 500.html" do assert render_to_string(<%= @web_namespace %>.ErrorHTML, "500", "html", []) == "Internal Server Error" end end ================================================ FILE: installer/templates/phx_test/controllers/error_json_test.exs.eex ================================================ defmodule <%= @web_namespace %>.ErrorJSONTest do use <%= @web_namespace %>.ConnCase, async: true test "renders 404" do assert <%= @web_namespace %>.ErrorJSON.render("404.json", %{}) == %{errors: %{detail: "Not Found"}} end test "renders 500" do assert <%= @web_namespace %>.ErrorJSON.render("500.json", %{}) == %{errors: %{detail: "Internal Server Error"}} end end ================================================ FILE: installer/templates/phx_test/controllers/page_controller_test.exs.eex ================================================ defmodule <%= @web_namespace %>.PageControllerTest do use <%= @web_namespace %>.ConnCase test "GET /", %{conn: conn} do conn = get(conn, ~p"/") assert html_response(conn, 200) =~ "Peace of mind from prototype to production" end end ================================================ FILE: installer/templates/phx_test/support/conn_case.ex.eex ================================================ defmodule <%= @web_namespace %>.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 <%= @web_namespace %>.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 <%= @endpoint_module %> use <%= @web_namespace %>, :verified_routes # Import conveniences for testing with connections import Plug.Conn import Phoenix.ConnTest import <%= @web_namespace %>.ConnCase end end<%= if @ecto do %> setup tags do <%= @app_module %>.DataCase.setup_sandbox(tags) {:ok, conn: Phoenix.ConnTest.build_conn()} end<% else %> setup _tags do {:ok, conn: Phoenix.ConnTest.build_conn()} end<% end %> end ================================================ FILE: installer/templates/phx_umbrella/README.md.eex ================================================ # <%= @root_app_module %> ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/README.md.eex ================================================ # <%= @app_module %> **TODO: Add description** ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/config/config.exs.eex ================================================ import Config <%= if @namespaced? || @ecto do %> # Configure Mix tasks and generators config :<%= @app_name %><%= if @namespaced? do %>, namespace: <%= @app_module %><% end %><%= if @ecto do %>, ecto_repos: [<%= @app_module %>.Repo]<% end %><% end %><%= if @mailer do %> # Configure the mailer # # By default it uses the "Local" adapter which stores the emails # locally. You can see the emails in your browser, at "/dev/mailbox". # # For production it's recommended to configure a different adapter # at the `config/runtime.exs`. config :<%= @app_name %>, <%= @app_module %>.Mailer, adapter: Swoosh.Adapters.Local<% end %> ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/formatter.exs.eex ================================================ [<%= if @ecto do %> import_deps: [:ecto, :ecto_sql], subdirectories: ["priv/*/migrations"],<% end %><%= if @html do %> plugins: [Phoenix.LiveView.HTMLFormatter],<% end %> inputs: [<%= if @html do %>"*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}"<% else %>"*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"<% end %><%= if @ecto do %>, "priv/*/seeds.exs"<% end %>] ] ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/gitignore.eex ================================================ # 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"). <%= @app_name %>-*.tar ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/lib/app_name/application.ex.eex ================================================ defmodule <%= @app_module %>.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 = [<%= if @ecto do %> <%= @app_module %>.Repo,<% end %><%= if @adapter_app == :ecto_sqlite3 do %> {Ecto.Migrator, repos: Application.fetch_env!(<%= inspect(String.to_atom(@app_name)) %>, :ecto_repos), skip: skip_migrations?()},<% end %> {DNSCluster, query: Application.get_env(<%= inspect(String.to_atom(@app_name)) %>, :dns_cluster_query) || :ignore}, {Phoenix.PubSub, name: <%= @app_module %>.PubSub} # Start a worker by calling: <%= @app_module %>.Worker.start_link(arg) # {<%= @app_module %>.Worker, arg} ] Supervisor.start_link(children, strategy: :one_for_one, name: <%= @app_module %>.Supervisor) end<%= if @adapter_app == :ecto_sqlite3 do %> defp skip_migrations?() do # By default, sqlite migrations are run when using a release System.get_env("RELEASE_NAME") == nil end<% end %> end ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/lib/app_name.ex.eex ================================================ defmodule <%= @app_module %> do @moduledoc """ <%= @app_module %> 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 ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/mix.exs.eex ================================================ defmodule <%= @app_module %>.MixProject do use Mix.Project def project do [ app: :<%= @app_name %>, version: "0.1.0", build_path: "../../_build", config_path: "../../config/config.exs", deps_path: "../../deps", lockfile: "../../mix.lock", elixir: "~> 1.15", elixirc_paths: elixirc_paths(Mix.env()), start_permanent: Mix.env() == :prod, aliases: aliases(), deps: deps() ] end # Configuration for the OTP application. # # Type `mix help compile.app` for more information. def application do [ mod: {<%= @app_module %>.Application, []}, extra_applications: [:logger, :runtime_tools] ] 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 [ {:dns_cluster, "~> 0.2.0"}, {:phoenix_pubsub, "~> 2.1"}<%= if @ecto do %>, {:ecto_sql, "~> 3.13"}, {:<%= @adapter_app %>, ">= 0.0.0"}, {:jason, "~> 1.2"}<% end %><%= if @mailer do %>, {:swoosh, "~> 1.16"}, {:req, "~> 0.5"}<% end %> ] end # Aliases are shortcuts or tasks specific to the current project. # # See the documentation for `Mix` for more info on aliases. defp aliases do [ setup: ["deps.get"<%= if @ecto do %>, "ecto.setup"<% end %>]<%= if @ecto do %>, "ecto.setup": ["ecto.create", "ecto.migrate", "run #{__DIR__}/priv/repo/seeds.exs"], "ecto.reset": ["ecto.drop", "ecto.setup"], test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"]<% end %> ] end end ================================================ FILE: installer/templates/phx_umbrella/apps/app_name/test/test_helper.exs.eex ================================================ ExUnit.start()<%= if @ecto do %> <%= @adapter_config[:test_setup_all] %><% end %> ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/README.md.eex ================================================ # <%= @web_namespace %> To start your Phoenix server: * Run `mix setup` to install and setup dependencies * Start Phoenix endpoint with `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 ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/config/config.exs.eex ================================================ import Config <%= if @namespaced? || @ecto || @generators do %> config :<%= @web_app_name %><%= if @namespaced? do %>, namespace: <%= @web_namespace %><% end %><%= if @ecto do %>, ecto_repos: [<%= @app_module %>.Repo]<% end %><%= if @generators do %>, generators: <%= inspect @generators %><% end %> <% end %># Configures the endpoint config :<%= @web_app_name %>, <%= @endpoint_module %>, url: [host: "localhost"], adapter: <%= inspect @web_adapter_module %>, render_errors: [ formats: [<%= if @html do%>html: <%= @web_namespace %>.ErrorHTML, <% end %>json: <%= @web_namespace %>.ErrorJSON], layout: false ], pubsub_server: <%= @app_module %>.PubSub, live_view: [signing_salt: "<%= @lv_signing_salt %>"]<%= if @javascript do %> # Configure esbuild (the version is required) config :esbuild, version: "0.25.4", <%= @web_app_name %>: [ args: ~w(js/app.js --bundle --target=es2022 --outdir=../priv/static/assets/js --external:/fonts/* --external:/images/* --alias:@=.), cd: Path.expand("../apps/<%= @web_app_name %>/assets", __DIR__), env: %{"NODE_PATH" => [Path.expand("../deps", __DIR__), Mix.Project.build_path()]} ]<% end %><%= if @css do %> # Configure tailwind (the version is required) config :tailwind, version: "4.1.12", <%= @web_app_name %>: [ args: ~w( --input=assets/css/app.css --output=priv/static/assets/css/app.css ), cd: Path.expand("../apps/<%= @web_app_name %>", __DIR__) ]<% end %> ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/config/dev.exs.eex ================================================ import Config # 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 :<%= @web_app_name %>, <%= @endpoint_module %>,<%= if @inside_docker_env? do %> # Bind to 0.0.0.0 to expose the server to the docker host machine. # This makes make the service accessible from any network interface. # Change to `ip: {127, 0, 0, 1}` to allow access only from the server machine. http: [ip: {0, 0, 0, 0}],<% else %> # 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}],<% end %> check_origin: false, code_reloader: true, debug_errors: true, secret_key_base: "<%= @secret_key_base_dev %>", watchers: <%= if @javascript or @css do %>[<%= if @javascript do %> esbuild: {Esbuild, :install_and_run, [:<%= @web_app_name %>, ~w(--sourcemap=inline --watch)]}<%= if @css, do: "," %><% end %><%= if @css do %> tailwind: {Tailwind, :install_and_run, [:<%= @web_app_name %>, ~w(--watch)]}<% end %> ]<% else %>[]<% end %> # ## 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.<%= if @html do %> # Reload browser tabs when matching files change. config :<%= @web_app_name %>, <%= @endpoint_module %>, live_reload: [ web_console_logger: true, patterns: [ # Static assets, except user uploads ~r"priv/static/(?!uploads/).*\.(js|css|png|jpeg|jpg|gif|svg)$"<%= @config_regex_E %>,<%= if @gettext do %> # Gettext translations ~r"priv/gettext/.*\.po$"<%= @config_regex_E %>,<% end %> # Router, Controllers, LiveViews and LiveComponents ~r"lib/<%= @web_app_name %>/router\.ex$"<%= @config_regex_E %>, ~r"lib/<%= @web_app_name %>/(controllers|live|components)/.*\.(ex|heex)$"<%= @config_regex_E %> ] ]<% end %> # Enable dev routes for dashboard and mailbox config :<%= @web_app_name %>, dev_routes: true ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/config/prod.exs.eex ================================================ import Config # Note we also include the path to a cache manifest # containing the digested version of static files. This # manifest is generated by the `mix phx.digest` task, # which you should run after static files are built and # before starting your production server. config :<%= @web_app_name %>, <%= @endpoint_module %>, url: [host: "example.com", port: 80], cache_static_manifest: "priv/static/cache_manifest.json" # 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 :<%= @web_app_name %>, <%= @endpoint_module %>, force_ssl: [ rewrite_on: [:x_forwarded_proto], exclude: [ # paths: ["/health"], hosts: ["localhost", "127.0.0.1"] ] ] ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/config/runtime.exs.eex ================================================ # 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 """ config :<%= @web_app_name %>, <%= @endpoint_module %>, http: [ # Enable IPv6 and bind on all interfaces. # Set it to {0, 0, 0, 0, 0, 0, 0, 1} for local network only access. ip: {0, 0, 0, 0, 0, 0, 0, 0} ], secret_key_base: secret_key_base # ## Using releases # # If you are doing OTP releases, you need to instruct Phoenix # to start each relevant endpoint: # # config :<%= @web_app_name %>, <%= @endpoint_module %>, server: true # # Then you can assemble a release by calling `mix release`. # See `mix help release` for more information. # ## SSL Support # # To get SSL working, you will need to add the `https` key # to your endpoint configuration: # # config :<%= @web_app_name %>, <%= @endpoint_module %>, # 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 :<%= @web_app_name %>, <%= @endpoint_module %>, # force_ssl: [hsts: true] # # Check `Plug.SSL` for all available options in `force_ssl`.<%= if @mailer do %> # ## Configuring the mailer # # In production you need to configure the mailer to use a different adapter. # Here is an example configuration for Mailgun: # # config :<%= @app_name %>, <%= @app_module %>.Mailer, # adapter: Swoosh.Adapters.Mailgun, # api_key: System.get_env("MAILGUN_API_KEY"), # domain: System.get_env("MAILGUN_DOMAIN") # # Most non-SMTP adapters require an API client. Swoosh supports Req, Hackney, # and Finch out-of-the-box. This configuration is typically done at # compile-time in your config/prod.exs: # # config :swoosh, :api_client, Swoosh.ApiClient.Req # # See https://hexdocs.pm/swoosh/Swoosh.html#module-installation for details.<% end %> ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/config/test.exs.eex ================================================ import Config # We don't run a server during test. If one is required, # you can enable the server option below. config :<%= @web_app_name %>, <%= @endpoint_module %>, http: [ip: {127, 0, 0, 1}, port: 4002], secret_key_base: "<%= @secret_key_base_test %>", server: false ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/formatter.exs.eex ================================================ [ import_deps: [:phoenix],<%= if @html do %> plugins: [Phoenix.LiveView.HTMLFormatter],<% end %> inputs: [<%= if @html do %>"*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}"<% else %>"*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"<% end %>] ] ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/gitignore.eex ================================================ # 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"). <%= @web_app_name %>-*.tar <%= if @javascript or @css do %> # Ignore assets that are produced by build tools. /priv/static/assets/ # Ignore digested assets cache. /priv/static/cache_manifest.json # In case you use Node.js/npm, you want to ignore these. npm-debug.log /assets/node_modules/ <% end %><%= if @adapter_app == :ecto_sqlite3 do %> # Database files *.db *.db-* <% end %> ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/lib/app_name/application.ex.eex ================================================ defmodule <%= @web_namespace %>.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 = [ <%= @web_namespace %>.Telemetry, # Start a worker by calling: <%= @web_namespace %>.Worker.start_link(arg) # {<%= @web_namespace %>.Worker, arg}, # Start to serve requests, typically the last entry <%= @endpoint_module %> ] # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options opts = [strategy: :one_for_one, name: <%= @web_namespace %>.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 <%= @endpoint_module %>.config_change(changed, removed) :ok end end ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/lib/app_name.ex.eex ================================================ defmodule <%= @web_namespace %> 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 <%= @web_namespace %>, :controller use <%= @web_namespace %>, :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<%= if @html do %> import Phoenix.LiveView.Router<% end %> end end def channel do quote do use Phoenix.Channel end end def controller do quote do use Phoenix.Controller, formats: [:html, :json]<%= if @gettext do %> use Gettext, backend: <%= @web_namespace %>.Gettext<% end %> import Plug.Conn unquote(verified_routes()) end end<%= if @html do %> def live_view do quote do use Phoenix.LiveView unquote(html_helpers()) end end def live_component do quote do use Phoenix.LiveComponent unquote(html_helpers()) end end def html do quote do use Phoenix.Component # Import convenience functions from controllers import Phoenix.Controller, only: [get_csrf_token: 0, view_module: 1, view_template: 1] # Include general helpers for rendering HTML unquote(html_helpers()) end end defp html_helpers do quote do<%= if @gettext do %> # Translation use Gettext, backend: <%= @web_namespace %>.Gettext <% end %> # HTML escaping functionality import Phoenix.HTML # Core UI components import <%= @web_namespace %>.CoreComponents # Common modules used in templates alias Phoenix.LiveView.JS alias <%= @web_namespace %>.Layouts # Routes generation with the ~p sigil unquote(verified_routes()) end end<% end %> def verified_routes do quote do use Phoenix.VerifiedRoutes, endpoint: <%= @endpoint_module %>, router: <%= @web_namespace %>.Router, statics: <%= @web_namespace %>.static_paths() end end @doc """ When used, dispatch to the appropriate controller/view/etc. """ defmacro __using__(which) when is_atom(which) do apply(__MODULE__, which, []) end end ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/mix.exs.eex ================================================ defmodule <%= @web_namespace %>.MixProject do use Mix.Project def project do [ app: :<%= @web_app_name %>, version: "0.1.0", build_path: "../../_build", config_path: "../../config/config.exs", deps_path: "../../deps", lockfile: "../../mix.lock", elixir: "~> 1.15", elixirc_paths: elixirc_paths(Mix.env()), start_permanent: Mix.env() == :prod, aliases: aliases(), deps: deps(),<%= if @html do %> compilers: [:phoenix_live_view] ++ Mix.compilers(),<% end %> listeners: [Phoenix.CodeReloader] ] end # Configuration for the OTP application. # # Type `mix help compile.app` for more information. def application do [ mod: {<%= @web_namespace %>.Application, []}, extra_applications: [:logger, :runtime_tools] ] 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_dep %>,<%= if @ecto do %> {:phoenix_ecto, "~> 4.5"},<% end %><%= if @html do %> {:phoenix_html, "~> 4.1"}, {:phoenix_live_reload, "~> 1.2", only: :dev}, {:phoenix_live_view, "~> 1.1.0"}, {:lazy_html, ">= 0.1.0", only: :test},<% end %><%= if @dashboard do %> {:phoenix_live_dashboard, "~> 0.8.3"},<% end %><%= if @javascript do %> {:esbuild, "~> 0.10", runtime: Mix.env() == :dev},<% end %><%= if @css do %> {:tailwind, "~> 0.3", runtime: Mix.env() == :dev}, {:heroicons, github: "tailwindlabs/heroicons", tag: "v2.2.0", sparse: "optimized", app: false, compile: false, depth: 1},<% end %> {:telemetry_metrics, "~> 1.0"}, {:telemetry_poller, "~> 1.0"},<%= if @gettext do %> {:gettext, "~> 1.0"},<% end %><%= if @app_name != @web_app_name do %> {:<%= @app_name %>, in_umbrella: true},<% end %> {:jason, "~> 1.2"}, {<%= inspect @web_adapter_app %>, "<%= @web_adapter_vsn %>"} ] end # Aliases are shortcuts or tasks specific to the current project. # # See the documentation for `Mix` for more info on aliases. defp aliases do [ setup: ["deps.get"<%= if @asset_builders != [] do %>, "assets.setup", "assets.build"<% end %>]<%= if @ecto do %>, test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"]<% end %><%= if @asset_builders != [] do %>, "assets.setup": <%= inspect Enum.map(@asset_builders, &"#{&1}.install --if-missing") %>, "assets.build": <%= inspect ["compile" | Enum.map(@asset_builders, &"#{&1} #{@web_app_name}")] %>, "assets.deploy": [ <%= Enum.map(@asset_builders, &" \"#{&1} #{@web_app_name} --minify\",\n") ++ [" \"phx.digest\""] %> ]<% end %> ] end end ================================================ FILE: installer/templates/phx_umbrella/apps/app_name_web/test/test_helper.exs.eex ================================================ ExUnit.start()<%= if @ecto do %> <%= @adapter_config[:test_setup_all] %><% end %> ================================================ FILE: installer/templates/phx_umbrella/config/config.exs.eex ================================================ # This file is responsible for configuring your umbrella # and **all applications** and their dependencies with the # help of the Config module. # # Note that all applications in your umbrella share the # same configuration and dependencies, which is why they # all use the same configuration file. If you want different # configurations or dependencies per app, it is best to # move said applications out of the umbrella. import Config ================================================ FILE: installer/templates/phx_umbrella/config/dev.exs.eex ================================================ import Config # Do not include metadata nor timestamps in development logs config :logger, :default_formatter, format: "[$level] $message\n" # Initialize plugs at runtime for faster development compilation config :phoenix, :plug_init_mode, :runtime<%= if @html do %> config :phoenix_live_view, # Include debug annotations and locations in rendered markup. # Changing this configuration will require mix clean and a full recompile. debug_heex_annotations: true, debug_attributes: true, # Enable helpful, but potentially expensive runtime checks enable_expensive_runtime_checks: true<% end %><%= if @mailer do %> # Disable swoosh api client as it is only required for production adapters. config :swoosh, :api_client, false<% end %> # Set a higher stacktrace during development. Avoid configuring such # in production as building large stacktraces may be expensive. config :phoenix, :stacktrace_depth, 20 ================================================ FILE: installer/templates/phx_umbrella/config/extra_config.exs.eex ================================================ import Config # 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 # 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" ================================================ FILE: installer/templates/phx_umbrella/config/prod.exs.eex ================================================ import Config <%= if @mailer do %> # Configure Swoosh API Client config :swoosh, :api_client, Swoosh.ApiClient.Req # Disable Swoosh Local Memory Storage config :swoosh, local: false<% end %> # 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. ================================================ FILE: installer/templates/phx_umbrella/config/runtime.exs.eex ================================================ 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. config :<%= @web_app_name %>, <%= @endpoint_module %>, http: [port: String.to_integer(System.get_env("PORT", "4000"))] if config_env() == :prod do config :<%= @app_name %>, :dns_cluster_query, System.get_env("DNS_CLUSTER_QUERY") end ================================================ FILE: installer/templates/phx_umbrella/config/test.exs.eex ================================================ import Config # Print only warnings and errors during test config :logger, level: :warning<%= if @mailer do %> # In test we don't send emails config :<%= @app_name %>, <%= @app_module %>.Mailer, adapter: Swoosh.Adapters.Test # Disable swoosh api client as it is only required for production adapters config :swoosh, :api_client, false<% end %> # Initialize plugs at runtime for faster test compilation config :phoenix, :plug_init_mode, :runtime<%= if @html do %> # Enable helpful, but potentially expensive runtime checks config :phoenix_live_view, enable_expensive_runtime_checks: true<% end %> # Sort query params output of verified routes for robust url comparisons config :phoenix, sort_verified_routes_query_params: true ================================================ FILE: installer/templates/phx_umbrella/formatter.exs.eex ================================================ [<%= if @html do %> plugins: [Phoenix.LiveView.HTMLFormatter],<% end %> inputs: ["mix.exs", "config/*.exs"], subdirectories: ["apps/*"] ] ================================================ FILE: installer/templates/phx_umbrella/gitignore.eex ================================================ # 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/ <%= if @adapter_app == :ecto_sqlite3 do %> # Database files *.db *.db-* <% end %> ================================================ FILE: installer/templates/phx_umbrella/mix.exs.eex ================================================ defmodule <%= @root_app_module %>.MixProject do use Mix.Project def project do [ apps_path: "apps", version: "0.1.0", start_permanent: Mix.env() == :prod, deps: deps(), aliases: aliases(), listeners: [Phoenix.CodeReloader] ] end def cli do [ preferred_envs: [precommit: :test] ] end # Dependencies can be Hex packages: # # {:mydep, "~> 0.3.0"} # # Or git/path repositories: # # {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1.0"} # # Type "mix help deps" for more examples and options. # # Dependencies listed here are available only for this project # and cannot be accessed from applications inside the apps/ folder. defp deps do<%= if @html do %> [ <%= if @dev or @phoenix_version.pre != [] do %><%= @phoenix_dep_umbrella_root %>, <% end %># Required to run "mix format" on ~H/.heex files from the umbrella root {:phoenix_live_view, ">= 0.0.0"} ]<% else %> []<% end %> 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. # # Aliases listed here are available only for this project # and cannot be accessed from applications inside the apps/ folder. defp aliases do [ # run `mix setup` in all child apps setup: ["cmd mix setup"], precommit: ["compile --warnings-as-errors", "deps.unlock --unused", "format", "test"] ] end end ================================================ FILE: installer/templates/phx_web/components/core_components.ex.eex ================================================ defmodule <%= @web_namespace %>.CoreComponents do @moduledoc """ Provides core UI components. At first glance, this module may seem daunting, but its goal is to provide core building blocks for your application, such as tables, forms, and inputs. The components consist mostly of markup and are well-documented with doc strings and declarative assigns. You may customize and style them in any way you want, based on your application growth and needs. The foundation for styling is Tailwind CSS, a utility-first CSS framework, augmented with daisyUI, a Tailwind CSS plugin that provides UI components and themes. Here are useful references: * [daisyUI](https://daisyui.com/docs/intro/) - a good place to get started and see the available components. * [Tailwind CSS](https://tailwindcss.com) - the foundational framework we build on. You will use it for layout, sizing, flexbox, grid, and spacing. * [Heroicons](https://heroicons.com) - see `icon/1` for usage. * [Phoenix.Component](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html) - the component system used by Phoenix. Some components, such as `<.link>` and `<.form>`, are defined there. """ use Phoenix.Component<%= if @gettext do %> use Gettext, backend: <%= @web_namespace %>.Gettext<% end %><%= if @live do %> alias Phoenix.LiveView.JS<% end %> @doc """ Renders flash notices. ## Examples <.flash kind={:info} flash={@flash} /> <.flash kind={:info} phx-mounted={show("#flash")}>Welcome Back! """ attr :id, :string, doc: "the optional id of flash container" attr :flash, :map, default: %{}, doc: "the map of flash messages to display" attr :title, :string, default: nil attr :kind, :atom, values: [:info, :error], doc: "used for styling and flash lookup" attr :rest, :global, doc: "the arbitrary HTML attributes to add to the flash container" slot :inner_block, doc: "the optional inner block that renders the flash message" def flash(assigns) do assigns = assign_new(assigns, :id, fn -> "flash-#{assigns.kind}" end) ~H"""
phx-click={JS.push("lv:clear-flash", value: %{key: @kind}) |> hide("##{@id}")}<% else %> data-flash<% end %> role="alert" class="toast toast-top toast-end z-50" {@rest} >
<.icon :if={@kind == :info} name="hero-information-circle" class="size-5 shrink-0" /> <.icon :if={@kind == :error} name="hero-exclamation-circle" class="size-5 shrink-0" />

{@title}

{msg}

""" end @doc """ Renders a button with navigation support. ## Examples <.button>Send! <.button phx-click="go" variant="primary">Send! <.button navigate={~p"/"}>Home """ attr :rest, :global, include: ~w(href navigate patch method download name value disabled) attr :class, :any attr :variant, :string, values: ~w(primary) slot :inner_block, required: true def button(%{rest: rest} = assigns) do variants = %{"primary" => "btn-primary", nil => "btn-primary btn-soft"} assigns = assign_new(assigns, :class, fn -> ["btn", Map.fetch!(variants, assigns[:variant])] end) if rest[:href] || rest[:navigate] || rest[:patch] do ~H""" <.link class={@class} {@rest}> {render_slot(@inner_block)} """ else ~H""" """ end end @doc """ Renders an input with label and error messages. A `Phoenix.HTML.FormField` may be passed as argument, which is used to retrieve the input name, id, and values. Otherwise all attributes may be passed explicitly. ## Types This function accepts all HTML input types, considering that: * You may also set `type="select"` to render a ` """ end def input(%{type: "checkbox"} = assigns) do assigns = assign_new(assigns, :checked, fn -> Phoenix.HTML.Form.normalize_value("checkbox", assigns[:value]) end) ~H"""
<.error :for={msg <- @errors}>{msg}
""" end def input(%{type: "select"} = assigns) do ~H"""
<.error :for={msg <- @errors}>{msg}
""" end def input(%{type: "textarea"} = assigns) do ~H"""
<.error :for={msg <- @errors}>{msg}
""" end # All other inputs text, datetime-local, url, password, etc. are handled here... def input(assigns) do ~H"""
<.error :for={msg <- @errors}>{msg}
""" end # Helper used by inputs to generate form errors defp error(assigns) do ~H"""

<.icon name="hero-exclamation-circle" class="size-5" /> {render_slot(@inner_block)}

""" end @doc """ Renders a header with title. """ slot :inner_block, required: true slot :subtitle slot :actions def header(assigns) do ~H"""

{render_slot(@inner_block)}

{render_slot(@subtitle)}

{render_slot(@actions)}
""" end @doc """ Renders a table with generic styling. ## Examples <.table id="users" rows={@users}> <:col :let={user} label="id">{user.id} <:col :let={user} label="username">{user.username} """ attr :id, :string, required: true attr :rows, :list, required: true attr :row_id, :any, default: nil, doc: "the function for generating the row id" attr :row_click, :any, default: nil, doc: "the function for handling phx-click on each row" attr :row_item, :any, default: &Function.identity/1, doc: "the function for mapping each row before calling the :col and :action slots" slot :col, required: true do attr :label, :string end slot :action, doc: "the slot for showing user actions in the last table column" def table(assigns) do assigns = with %{rows: %Phoenix.LiveView.LiveStream{}} <- assigns do assign(assigns, row_id: assigns.row_id || fn {id, _item} -> id end) end ~H"""
{col[:label]} <%= maybe_eex_gettext.("Actions", @gettext) %>
{render_slot(col, @row_item.(row))}
<%%= for action <- @action do %> {render_slot(action, @row_item.(row))} <%% end %>
""" end @doc """ Renders a data list. ## Examples <.list> <:item title="Title">{@post.title} <:item title="Views">{@post.views} """ slot :item, required: true do attr :title, :string, required: true end def list(assigns) do ~H"""
  • {item.title}
    {render_slot(item)}
""" end @doc """ Renders a [Heroicon](https://heroicons.com). Heroicons come in three styles – outline, solid, and mini. By default, the outline style is used, but solid and mini may be applied by using the `-solid` and `-mini` suffix. You can customize the size and colors of the icons by setting width, height, and background color classes. Icons are extracted from the `deps/heroicons` directory and bundled within your compiled app.css by the plugin in `assets/vendor/heroicons.js`. ## Examples <.icon name="hero-x-mark" /> <.icon name="hero-arrow-path" class="ml-1 size-3 motion-safe:animate-spin" /> """ attr :name, :string, required: true attr :class, :any, default: "size-4" def icon(%{name: "hero-" <> _} = assigns) do ~H""" """ end<%= if @live do %> ## JS Commands def show(js \\ %JS{}, selector) do JS.show(js, to: selector, time: 300, transition: {"transition-all ease-out duration-300", "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95", "opacity-100 translate-y-0 sm:scale-100"} ) end def hide(js \\ %JS{}, selector) do JS.hide(js, to: selector, time: 200, transition: {"transition-all ease-in duration-200", "opacity-100 translate-y-0 sm:scale-100", "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"} ) end<% end %> @doc """ Translates an error message using gettext. """<%= if @gettext do %> def translate_error({msg, opts}) do # When using gettext, we typically pass the strings we want # to translate as a static argument: # # # Translate the number of files with plural rules # dngettext("errors", "1 file", "%{count} files", count) # # However the error messages in our forms and APIs are generated # dynamically, so we need to translate them by calling Gettext # with our gettext backend as first argument. Translations are # available in the errors.po file (as we use the "errors" domain). if count = opts[:count] do Gettext.dngettext(<%= @web_namespace %>.Gettext, "errors", msg, msg, count, opts) else Gettext.dgettext(<%= @web_namespace %>.Gettext, "errors", msg, opts) end end<% else %> def translate_error({msg, opts}) do # You can make use of gettext to translate error messages by # uncommenting and adjusting the following code: # if count = opts[:count] do # Gettext.dngettext(<%= @web_namespace %>.Gettext, "errors", msg, msg, count, opts) # else # Gettext.dgettext(<%= @web_namespace %>.Gettext, "errors", msg, opts) # end Enum.reduce(opts, msg, fn {key, value}, acc -> String.replace(acc, "%{#{key}}", fn _ -> to_string(value) end) end) end<% end %> @doc """ Translates the errors for a field from a keyword list of errors. """ def translate_errors(errors, field) when is_list(errors) do for {^field, {msg, opts}} <- errors, do: translate_error({msg, opts}) end end ================================================ FILE: installer/templates/phx_web/components/layouts/root.html.heex.eex ================================================ <.live_title default="<%= @app_module %>" suffix=" · Phoenix Framework"> {assigns[:page_title]} <%= if not @css do %> <% end %> <%= if @css do %> <% end %> {@inner_content} ================================================ FILE: installer/templates/phx_web/components/layouts.ex.eex ================================================ defmodule <%= @web_namespace %>.Layouts do @moduledoc """ This module holds layouts and related functionality used by your application. """ use <%= @web_namespace %>, :html # Embed all files in layouts/* within this module. # The default root.html.heex file contains the HTML # skeleton of your application, namely HTML headers # and other static content. embed_templates "layouts/*" @doc """ Renders your app layout. This function is typically invoked from every template, and it often contains your application menu, sidebar, or similar. ## Examples

Content

 """ attr :flash, :map, required: true, doc: "the map of flash messages" attr :current_scope, :map, default: nil, doc: "the current [scope](https://hexdocs.pm/phoenix/scopes.html)" slot :inner_block, required: true def app(assigns) do ~H"""
v{Application.spec(:phoenix, :vsn)}
{render_slot(@inner_block)}
<.flash_group flash={@flash} /> """ end @doc """ Shows the flash group with standard titles and content. ## Examples <.flash_group flash={@flash} /> """ attr :flash, :map, required: true, doc: "the map of flash messages" attr :id, :string, default: "flash-group", doc: "the optional id of flash container" def flash_group(assigns) do ~H"""
<.flash kind={:info} flash={@flash} /> <.flash kind={:error} flash={@flash} /><%= if @live and @javascript do %> <.flash id="client-error" kind={:error} title=<%= maybe_heex_attr_gettext.("We can't find the internet", @gettext) %> phx-disconnected={show(".phx-client-error #client-error") |> JS.remove_attribute("hidden")} phx-connected={hide("#client-error") |> JS.set_attribute({"hidden", ""})} hidden > <%= maybe_eex_gettext.("Attempting to reconnect", @gettext) %> <.icon name="hero-arrow-path" class="ml-1 size-3 motion-safe:animate-spin" /> <.flash id="server-error" kind={:error} title=<%= maybe_heex_attr_gettext.("Something went wrong!", @gettext) %> phx-disconnected={show(".phx-server-error #server-error") |> JS.remove_attribute("hidden")} phx-connected={hide("#server-error") |> JS.set_attribute({"hidden", ""})} hidden > <%= maybe_eex_gettext.("Attempting to reconnect", @gettext) %> <.icon name="hero-arrow-path" class="ml-1 size-3 motion-safe:animate-spin" /> <% end %>
""" end<%= if @css do %> @doc """ Provides dark vs light theme toggle based on themes defined in app.css. See in root.html.heex which applies the theme before page load. """ def theme_toggle(assigns) do ~H"""
""" end<% end %> end ================================================ FILE: installer/templates/phx_web/controllers/error_html.ex.eex ================================================ defmodule <%= @web_namespace %>.ErrorHTML do @moduledoc """ This module is invoked by your endpoint in case of errors on HTML requests. See config/config.exs. """ use <%= @web_namespace %>, :html # If you want to customize your error pages, # uncomment the embed_templates/1 call below # and add pages to the error directory: # # * lib/<%= @lib_web_name %>/controllers/error_html/404.html.heex # * lib/<%= @lib_web_name %>/controllers/error_html/500.html.heex # # embed_templates "error_html/*" # The default is to render a plain text page based on # the template name. For example, "404.html" becomes # "Not Found". def render(template, _assigns) do Phoenix.Controller.status_message_from_template(template) end end ================================================ FILE: installer/templates/phx_web/controllers/error_json.ex.eex ================================================ defmodule <%= @web_namespace %>.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 ================================================ FILE: installer/templates/phx_web/controllers/page_controller.ex.eex ================================================ defmodule <%= @web_namespace %>.PageController do use <%= @web_namespace %>, :controller def home(conn, _params) do render(conn, :home) end end ================================================ FILE: installer/templates/phx_web/controllers/page_html/home.html.heex.eex ================================================

Phoenix Framework v{Application.spec(:phoenix, :vsn)}

<%= if @css do %> <% end %>

Peace of mind from prototype to production.

Build rich, interactive web applications quickly, with less code and fewer moving parts. Join our growing community of developers using Phoenix to craft APIs, HTML5 apps and more, for fun or at scale.

Guides & Docs Source Code Changelog
================================================ FILE: installer/templates/phx_web/controllers/page_html.ex.eex ================================================ defmodule <%= @web_namespace %>.PageHTML do @moduledoc """ This module contains pages rendered by PageController. See the `page_html` directory for all templates available. """ use <%= @web_namespace %>, :html embed_templates "page_html/*" end ================================================ FILE: installer/templates/phx_web/endpoint.ex.eex ================================================ defmodule <%= @endpoint_module %> do use Phoenix.Endpoint, otp_app: :<%= @web_app_name %> # 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: "_<%= @web_app_name %>_key", signing_salt: "<%= @signing_salt %>", same_site: "Lax" ] <%= if !(@dashboard || @live) do %><%= "# " %><% end %>socket "/live", Phoenix.LiveView.Socket, <%= if !(@dashboard || @live) do %><%= "# " %><% end %> websocket: [connect_info: [session: @session_options]], <%= if !(@dashboard || @live) do %><%= "# " %><% end %> 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: :<%= @web_app_name %>, gzip: not code_reloading?, only: <%= @web_namespace %>.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<%= if @html do %> socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket plug Phoenix.LiveReloader<% end %> plug Phoenix.CodeReloader<%= if @ecto do %> plug Phoenix.Ecto.CheckRepoStatus, otp_app: :<%= @web_app_name %><% end %> end<%= if @dashboard do %> plug Phoenix.LiveDashboard.RequestLogger, param_key: "request_logger", cookie_key: "request_logger"<% 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 <%= @web_namespace %>.Router end ================================================ FILE: installer/templates/phx_web/router.ex.eex ================================================ defmodule <%= @web_namespace %>.Router do use <%= @web_namespace %>, :router<%= if @html do %> pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, html: {<%= @web_namespace %>.Layouts, :root} plug :protect_from_forgery plug :put_secure_browser_headers end<% end %> pipeline :api do plug :accepts, ["json"] end<%= if @html do %> scope "/", <%= @web_namespace %> do pipe_through :browser get "/", PageController, :home end # Other scopes may use custom stacks. # scope "/api", <%= @web_namespace %> do # pipe_through :api # end<% else %> scope "/api", <%= @web_namespace %> do pipe_through :api end<% end %><%= if @dashboard || @mailer do %> # Enable <%= [@dashboard && "LiveDashboard", @mailer && "Swoosh mailbox preview"] |> Enum.filter(&(&1)) |> Enum.join(" and ") %> in development if Application.compile_env(:<%= @web_app_name %>, :dev_routes) do<%= if @dashboard do %> # If you want to use the LiveDashboard in production, you should put # it behind authentication and allow only admins to access it. # If your application does not have an admins-only section yet, # you can use Plug.BasicAuth to set up some basic authentication # as long as you are also using SSL (which you should anyway). import Phoenix.LiveDashboard.Router<% end %> scope "/dev" do<%= if @html do %> pipe_through :browser<% else %> pipe_through [:fetch_session, :protect_from_forgery]<% end %> <%= if @dashboard do %> live_dashboard "/dashboard", metrics: <%= @web_namespace %>.Telemetry<% end %><%= if @mailer do %> forward "/mailbox", Plug.Swoosh.MailboxPreview<% end %> end end<% end %> end ================================================ FILE: installer/templates/phx_web/telemetry.ex.eex ================================================ defmodule <%= @web_namespace %>.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} ),<%= if @ecto do %> # Database Metrics summary("<%= @app_name %>.repo.query.total_time", unit: {:native, :millisecond}, description: "The sum of the other measurements" ), summary("<%= @app_name %>.repo.query.decode_time", unit: {:native, :millisecond}, description: "The time spent decoding the data received from the database" ), summary("<%= @app_name %>.repo.query.query_time", unit: {:native, :millisecond}, description: "The time spent executing the query" ), summary("<%= @app_name %>.repo.query.queue_time", unit: {:native, :millisecond}, description: "The time spent waiting for a database connection" ), summary("<%= @app_name %>.repo.query.idle_time", unit: {:native, :millisecond}, description: "The time the connection spent waiting before being checked out for the query" ),<% end %> # 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. # {<%= @web_namespace %>, :count_users, []} ] end end ================================================ FILE: installer/templates/usage-rules/assets.md ================================================ ### JS and CSS guidelines - **Use Tailwind CSS classes and custom CSS rules** to create polished, responsive, and visually stunning interfaces. - Tailwindcss v4 **no longer needs a tailwind.config.js** and uses a new import syntax in `app.css`: @import "tailwindcss" source(none); @source "../css"; @source "../js"; @source "../../lib/my_app_web"; - **Always use and maintain this import syntax** in the app.css file for projects generated with `phx.new` - **Never** use `@apply` when writing raw css - **Always** manually write your own tailwind-based components instead of using daisyUI for a unique, world-class design - Out of the box **only the app.js and app.css bundles are supported** - You cannot reference an external vendor'd script `src` or link `href` in the layouts - You must import the vendor deps into app.js and app.css to use them - **Never write inline tags within templates** ### UI/UX & design guidelines - **Produce world-class UI designs** with a focus on usability, aesthetics, and modern design principles - Implement **subtle micro-interactions** (e.g., button hover effects, and smooth transitions) - Ensure **clean typography, spacing, and layout balance** for a refined, premium look - Focus on **delightful details** like hover effects, loading states, and smooth page transitions ================================================ FILE: installer/templates/usage-rules/phoenix.md ================================================ ### 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 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 ================================================ FILE: installer/templates/usage-rules/project.md ================================================ 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 ================================================ FILE: installer/test/mix_helper.exs ================================================ # Get Mix output sent to the current # process to avoid polluting tests. Mix.shell(Mix.Shell.Process) defmodule MixHelper do import ExUnit.Assertions import ExUnit.CaptureIO def tmp_path do Path.expand("../../tmp", __DIR__) end defp random_string(len) do len |> :crypto.strong_rand_bytes() |> Base.url_encode64() |> binary_part(0, len) end def in_tmp(which, function) do base = Path.join([tmp_path(), random_string(10)]) path = Path.join([base, to_string(which)]) try do File.rm_rf!(path) File.mkdir_p!(path) File.cd!(path, function) after File.rm_rf!(base) end end def in_tmp_project(which, function) do conf_before = Application.get_env(:phoenix, :generators) || [] base = Path.join([tmp_path(), random_string(10)]) path = Path.join([base, to_string(which)]) try do File.rm_rf!(path) File.mkdir_p!(path) File.cd!(path, fn -> File.touch!("mix.exs") File.write!(".formatter.exs", """ [ import_deps: [:phoenix, :ecto, :ecto_sql], inputs: ["*.exs"] ] """) function.() end) after File.rm_rf!(base) Application.put_env(:phoenix, :generators, conf_before) end end def in_tmp_umbrella_project(which, function) do conf_before = Application.get_env(:phoenix, :generators) || [] base = Path.join([tmp_path(), random_string(10)]) path = Path.join([base, to_string(which)]) try do apps_path = Path.join(path, "apps") config_path = Path.join(path, "config") File.rm_rf!(path) File.mkdir_p!(path) File.mkdir_p!(apps_path) File.mkdir_p!(config_path) File.touch!(Path.join(path, "mix.exs")) for file <- ~w(config.exs dev.exs test.exs prod.exs) do File.write!(Path.join(config_path, file), "import Config\n") end File.cd!(apps_path, function) after Application.put_env(:phoenix, :generators, conf_before) File.rm_rf!(base) end end def in_project(app, path, fun) do %{name: name, file: file} = Mix.Project.pop() try do capture_io(:stderr, fn -> Mix.Project.in_project(app, path, [prune_code_paths: false], fn mod -> fun.(mod) Mix.Project.clear_deps_cache() end) end) after Mix.Project.push(name, file) end end def assert_file(file) do assert File.regular?(file), "Expected #{file} to exist, but does not" end def refute_file(file) do refute File.regular?(file), "Expected #{file} to not exist, but it does" end def assert_file(file, match) do cond do is_list(match) -> assert_file(file, &Enum.each(match, fn m -> assert &1 =~ m end)) is_binary(match) or is_struct(match, Regex) -> assert_file(file, &assert(&1 =~ match)) is_function(match, 1) -> assert_file(file) match.(File.read!(file)) true -> raise inspect({file, match}) end end def modify_file(path, function) when is_binary(path) and is_function(function, 1) do path |> File.read!() |> function.() |> write_file!(path) end defp write_file!(content, path) do File.write!(path, content) end def with_generator_env(app_name \\ :phoenix, new_env, fun) do config_before = Application.fetch_env(app_name, :generators) Application.put_env(app_name, :generators, new_env) try do fun.() after case config_before do {:ok, config} -> Application.put_env(app_name, :generators, config) :error -> Application.delete_env(app_name, :generators) end end end def with_scope_env(app_name, new_env, fun) do config_before = Application.fetch_env(app_name, :scopes) Application.put_env(app_name, :scopes, new_env) try do fun.() after case config_before do {:ok, config} -> Application.put_env(app_name, :scopes, config) :error -> Application.delete_env(app_name, :scopes) end end end def umbrella_mixfile_contents do """ defmodule Umbrella.MixProject do use Mix.Project def project do [ apps_path: "apps", deps: deps() ] end defp deps do [] end end """ end def flush do receive do _ -> flush() after 0 -> :ok end end end ================================================ FILE: installer/test/phx_new_ecto_test.exs ================================================ Code.require_file "mix_helper.exs", __DIR__ defmodule Mix.Tasks.Phx.New.EctoTest do use ExUnit.Case import MixHelper import ExUnit.CaptureIO setup do # The shell asks to install deps. # We will politely say not. send self(), {:mix_shell_input, :yes?, false} :ok end @app_name "phx_ecto" test "new without args" do assert capture_io(fn -> Mix.Tasks.Phx.New.Ecto.run([]) end) =~ "Creates a new Ecto project within an umbrella project." end test "new with barebones umbrella" do in_tmp_umbrella_project "new with barebones umbrella", fn -> files = ~w[../config/dev.exs ../config/test.exs ../config/prod.exs ../config/runtime.exs] Enum.each(files, &File.rm/1) assert_file "../config/config.exs", &refute(&1 =~ ~S[import_config "#{config_env()}.exs"]) Mix.Tasks.Phx.New.Ecto.run([@app_name]) assert_file "../config/config.exs", &assert(&1 =~ ~S[import_config "#{config_env()}.exs"]) end end test "new outside umbrella", config do in_tmp config.test, fn -> assert_raise Mix.Error, ~r"The ecto task can only be run within an umbrella's apps directory", fn -> Mix.Tasks.Phx.New.Ecto.run ["007invalid"] end end end test "new with defaults", config do in_tmp_umbrella_project config.test, fn -> Mix.Tasks.Phx.New.Ecto.run([@app_name]) # Install dependencies? assert_received {:mix_shell, :yes?, ["\nFetch and install dependencies?"]} # Instructions assert_received {:mix_shell, :info, ["\nWe are almost there" <> _ = msg]} assert msg =~ "$ cd phx_ecto" assert msg =~ "$ mix deps.get" assert_received {:mix_shell, :info, ["Then configure your database in config/dev.exs" <> _]} end end end ================================================ FILE: installer/test/phx_new_test.exs ================================================ Code.require_file("mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.NewTest do use ExUnit.Case, async: false import MixHelper import ExUnit.CaptureIO @app_name "phx_blog" setup do # The shell asks to install deps. # We will politely say not. send(self(), {:mix_shell_input, :yes?, false}) :ok end test "assets are in sync with priv" do for file <- ~w(favicon.ico phoenix.png) do assert File.read!("../priv/static/#{file}") == File.read!("templates/phx_static/#{file}") end end test "returns the version" do Mix.Tasks.Phx.New.run(["-v"]) assert_received {:mix_shell, :info, ["Phoenix installer v" <> _]} end test "new with defaults" do in_tmp("new with defaults", fn -> Mix.Tasks.Phx.New.run([@app_name]) assert_file("phx_blog/README.md") assert_file("phx_blog/AGENTS.md", fn file -> assert file =~ "### UI/UX & design guidelines" end) assert_file("phx_blog/.formatter.exs", fn file -> assert file =~ "import_deps: [:ecto, :ecto_sql, :phoenix]" assert file =~ "subdirectories: [\"priv/*/migrations\"]" assert file =~ "plugins: [Phoenix.LiveView.HTMLFormatter]" assert file =~ "inputs: [\"*.{heex,ex,exs}\", \"{config,lib,test}/**/*.{heex,ex,exs}\", \"priv/*/seeds.exs\"]" end) assert_file("phx_blog/mix.exs", fn file -> assert file =~ "app: :phx_blog" refute file =~ "deps_path: \"../../deps\"" refute file =~ "lockfile: \"../../mix.lock\"" end) assert_file("phx_blog/config/config.exs", fn file -> assert file =~ "ecto_repos: [PhxBlog.Repo]" assert file =~ "generators: [timestamp_type: :utc_datetime]" assert file =~ "config :phoenix, :json_library, Jason" assert file =~ ~s[cd: Path.expand("../assets", __DIR__),] refute file =~ "namespace: PhxBlog" refute file =~ "config :phx_blog, :generators" end) assert_file("phx_blog/config/prod.exs", fn file -> assert file =~ "config :logger, level: :info" end) assert_file("phx_blog/config/runtime.exs", fn file -> assert file =~ ~r/^ http: \[port: String.to_integer\(System.get_env\("PORT", "4000"\)\)\]$/m assert file =~ ~r/^\s+ip: {0, 0, 0, 0, 0, 0, 0, 0}$/m end) assert_file("phx_blog/lib/phx_blog/application.ex", ~r/defmodule PhxBlog.Application do/) assert_file("phx_blog/lib/phx_blog.ex", ~r/defmodule PhxBlog do/) assert_file("phx_blog/mix.exs", fn file -> assert file =~ "mod: {PhxBlog.Application, []}" assert file =~ "{:jason," assert file =~ "{:phoenix_live_dashboard," end) assert_file("phx_blog/lib/phx_blog_web.ex", fn file -> assert file =~ "defmodule PhxBlogWeb do" assert file =~ "import Phoenix.HTML" assert file =~ "Phoenix.LiveView" end) assert_file("phx_blog/test/phx_blog_web/controllers/page_controller_test.exs") assert_file("phx_blog/test/phx_blog_web/controllers/error_html_test.exs") assert_file("phx_blog/test/phx_blog_web/controllers/error_json_test.exs") assert_file("phx_blog/test/support/conn_case.ex") assert_file("phx_blog/test/test_helper.exs") assert_file( "phx_blog/lib/phx_blog_web/controllers/page_controller.ex", ~r/defmodule PhxBlogWeb.PageController/ ) assert_file( "phx_blog/lib/phx_blog_web/controllers/page_html.ex", ~r/defmodule PhxBlogWeb.PageHTML/ ) assert_file( "phx_blog/lib/phx_blog_web/controllers/error_html.ex", ~r/defmodule PhxBlogWeb.ErrorHTML/ ) assert_file( "phx_blog/lib/phx_blog_web/controllers/error_json.ex", ~r/defmodule PhxBlogWeb.ErrorJSON/ ) assert_file("phx_blog/lib/phx_blog_web/components/layouts.ex", fn file -> assert file =~ "defmodule PhxBlogWeb.Layouts" assert file =~ ~S|gettext("Attempting to reconnect")| end) assert_file("phx_blog/lib/phx_blog_web/components/core_components.ex", fn file -> assert file =~ ~S|gettext("close")| end) assert_file("phx_blog/lib/phx_blog_web/router.ex", fn file -> assert file =~ "defmodule PhxBlogWeb.Router" assert file =~ "live_dashboard" assert file =~ "import Phoenix.LiveDashboard.Router" end) assert_file("phx_blog/lib/phx_blog_web/endpoint.ex", fn file -> assert file =~ ~s|defmodule PhxBlogWeb.Endpoint| assert file =~ ~s|socket "/live"| assert file =~ ~s|plug Phoenix.LiveDashboard.RequestLogger| end) assert_file("phx_blog/lib/phx_blog_web/components/layouts/root.html.heex", fn file -> assert file =~ ~s|| end) assert_file("phx_blog/lib/phx_blog_web/controllers/page_html/home.html.heex") # assets assert_file("phx_blog/priv/static/images/logo.svg") assert_file("phx_blog/.gitignore", fn file -> assert file =~ "/priv/static/assets/" assert file =~ "phx_blog-*.tar" assert file =~ ~r/\n$/ end) assert_file("phx_blog/config/dev.exs", fn file -> assert file =~ "esbuild: {Esbuild," assert file =~ "lib/phx_blog_web/router\\.ex$" assert file =~ "lib/phx_blog_web/(controllers|live|components)/.*\\.(ex|heex)$" assert file =~ "http: [ip: {127, 0, 0, 1}]" end) # tailwind assert_file("phx_blog/assets/css/app.css", fn file -> assert file =~ "lib/phx_blog_web" end) refute File.exists?("phx_blog/priv/static/assets/css/app.css") refute File.exists?("phx_blog/priv/static/assets/js/app.js") assert File.exists?("phx_blog/assets/vendor") assert_file("phx_blog/config/config.exs", fn file -> assert file =~ "cd: Path.expand(\"../assets\", __DIR__)" assert file =~ "config :esbuild" end) # Ecto config = ~r/config :phx_blog, PhxBlog.Repo,/ assert_file("phx_blog/mix.exs", fn file -> assert file =~ "{:phoenix_ecto," assert file =~ "aliases: aliases()" assert file =~ "ecto.setup" assert file =~ "ecto.reset" end) assert_file("phx_blog/config/dev.exs", config) assert_file("phx_blog/config/test.exs", config) assert_file("phx_blog/config/runtime.exs", fn file -> assert file =~ config assert file =~ ~S|maybe_ipv6 = if System.get_env("ECTO_IPV6") in ~w(true 1), do: [:inet6], else: []| assert file =~ ~S|socket_options: maybe_ipv6| assert file =~ """ if System.get_env("PHX_SERVER") do config :phx_blog, PhxBlogWeb.Endpoint, server: true end """ assert file =~ ~S[host = System.get_env("PHX_HOST") || "example.com"] assert file =~ ~S|url: [host: host, port: 443, scheme: "https"],| end) assert_file( "phx_blog/config/test.exs", ~r/database: "phx_blog_test#\{System.get_env\("MIX_TEST_PARTITION"\)\}"/ ) assert_file("phx_blog/lib/phx_blog/repo.ex", ~r"defmodule PhxBlog.Repo") assert_file("phx_blog/lib/phx_blog_web.ex", ~r"defmodule PhxBlogWeb") assert_file( "phx_blog/lib/phx_blog_web/endpoint.ex", ~r"plug Phoenix.Ecto.CheckRepoStatus, otp_app: :phx_blog" ) assert_file("phx_blog/priv/repo/seeds.exs", ~r"PhxBlog.Repo.insert!") assert_file("phx_blog/test/support/data_case.ex", ~r"defmodule PhxBlog.DataCase") assert_file("phx_blog/priv/repo/migrations/.formatter.exs", ~r"import_deps: \[:ecto_sql\]") # LiveView refute_file("phx_blog/lib/phx_blog_web/live/page_live_view.ex") assert_file("phx_blog/assets/js/app.js", fn file -> assert file =~ ~s|import {LiveSocket} from "phoenix_live_view"| assert file =~ ~s|liveSocket.connect()| end) assert_file("phx_blog/mix.exs", fn file -> assert file =~ ~r":phoenix_live_view" assert file =~ ~r":lazy_html" end) assert_file( "phx_blog/lib/phx_blog_web/router.ex", &assert(&1 =~ ~s[plug :fetch_live_flash]) ) assert_file("phx_blog/lib/phx_blog_web/router.ex", &assert(&1 =~ ~s[plug :put_root_layout])) assert_file("phx_blog/lib/phx_blog_web/router.ex", &assert(&1 =~ ~s[PageController])) # Telemetry assert_file("phx_blog/mix.exs", fn file -> assert file =~ "{:telemetry_metrics," assert file =~ "{:telemetry_poller," end) assert_file("phx_blog/lib/phx_blog_web/telemetry.ex", fn file -> assert file =~ "defmodule PhxBlogWeb.Telemetry do" assert file =~ "{:telemetry_poller, measurements: periodic_measurements()" assert file =~ "defp periodic_measurements do" assert file =~ "# {PhxBlogWeb, :count_users, []}" assert file =~ "def metrics do" assert file =~ "summary(\"phoenix.endpoint.stop.duration\"," assert file =~ "summary(\"phoenix.router_dispatch.stop.duration\"," assert file =~ "# Database Metrics" assert file =~ "summary(\"phx_blog.repo.query.total_time\"," end) # Mailer assert_file("phx_blog/mix.exs", fn file -> assert file =~ "{:swoosh, \"~> 1.16\"}" assert file =~ "{:req, \"~> 0.5\"}" end) assert_file("phx_blog/lib/phx_blog/mailer.ex", fn file -> assert file =~ "defmodule PhxBlog.Mailer do" assert file =~ "use Swoosh.Mailer, otp_app: :phx_blog" end) assert_file("phx_blog/config/config.exs", fn file -> assert file =~ "config :phx_blog, PhxBlog.Mailer, adapter: Swoosh.Adapters.Local" end) assert_file("phx_blog/config/test.exs", fn file -> assert file =~ "config :swoosh" assert file =~ "config :phx_blog, PhxBlog.Mailer, adapter: Swoosh.Adapters.Test" end) assert_file("phx_blog/config/dev.exs", fn file -> assert file =~ "config :swoosh" end) assert_file("phx_blog/config/prod.exs", fn file -> assert file =~ "config :swoosh, api_client: Swoosh.ApiClient.Req" end) # Install dependencies? assert_received {:mix_shell, :yes?, ["\nFetch and install dependencies?"]} # Instructions assert_received {:mix_shell, :info, ["\nWe are almost there" <> _ = msg]} assert msg =~ "$ cd phx_blog" assert msg =~ "$ mix deps.get" assert_received {:mix_shell, :info, ["Then configure your database in config/dev.exs" <> _]} assert_received {:mix_shell, :info, ["Start your Phoenix app" <> _]} # Gettext assert_file("phx_blog/lib/phx_blog_web/gettext.ex", [ ~r"defmodule PhxBlogWeb.Gettext", ~r"use Gettext\.Backend, otp_app: :phx_blog" ]) assert File.exists?("phx_blog/priv/gettext/errors.pot") assert File.exists?("phx_blog/priv/gettext/en/LC_MESSAGES/errors.po") end) end test "new without defaults" do in_tmp("new without defaults", fn -> Mix.Tasks.Phx.New.run([ @app_name, "--no-html", "--no-assets", "--no-ecto", "--no-gettext", "--no-dashboard", "--no-mailer" ]) # No assets assert_file("phx_blog/.gitignore", fn file -> refute file =~ "/priv/static/assets/" assert file =~ ~r/\n$/ end) refute File.exists?("phx_blog/priv/static/images/logo.svg") assert_file("phx_blog/config/dev.exs", ~r/watchers: \[\]/) # No assets & No HTML refute_file("phx_blog/priv/static/assets/css/app.css") refute_file("phx_blog/priv/static/assets/js/app.js") # No Ecto config = ~r/config :phx_blog, PhxBlog.Repo,/ refute File.exists?("phx_blog/lib/phx_blog/repo.ex") assert_file("phx_blog/lib/phx_blog_web/endpoint.ex", fn file -> refute file =~ "plug Phoenix.Ecto.CheckRepoStatus, otp_app: :phx_blog" end) assert_file("phx_blog/lib/phx_blog_web/telemetry.ex", fn file -> refute file =~ "# Database Metrics" refute file =~ "summary(\"phx_blog.repo.query.total_time\"," end) assert_file("phx_blog/.formatter.exs", fn file -> assert file =~ "import_deps: [:phoenix]" assert file =~ "inputs: [\"*.{ex,exs}\", \"{config,lib,test}/**/*.{ex,exs}\"]" refute file =~ "subdirectories:" end) assert_file("phx_blog/mix.exs", &refute(&1 =~ ~r":phoenix_ecto")) assert_file("phx_blog/config/config.exs", fn file -> refute file =~ "config :esbuild" refute file =~ "config :phx_blog, :generators" refute file =~ "ecto_repos:" end) assert_file("phx_blog/config/dev.exs", fn file -> refute file =~ config assert file =~ "config :phoenix, :plug_init_mode, :runtime" end) assert_file("phx_blog/config/test.exs", &refute(&1 =~ config)) assert_file("phx_blog/config/runtime.exs", &refute(&1 =~ config)) assert_file("phx_blog/lib/phx_blog_web.ex", &refute(&1 =~ ~r"alias PhxBlog.Repo")) # No gettext refute_file("phx_blog/lib/phx_blog_web/gettext.ex") refute_file("phx_blog/priv/gettext/en/LC_MESSAGES/errors.po") refute_file("phx_blog/priv/gettext/errors.pot") assert_file("phx_blog/mix.exs", &refute(&1 =~ ~r":gettext")) assert_file( "phx_blog/lib/phx_blog_web.ex", &refute(&1 =~ ~r"use Gettext, backend: AmsMockWeb.Gettext") ) assert_file("phx_blog/config/dev.exs", &refute(&1 =~ ~r"gettext")) # No HTML assert File.exists?("phx_blog/test/phx_blog_web/controllers") assert File.exists?("phx_blog/lib/phx_blog_web/controllers") refute File.exists?("phx_blog/test/web/controllers/pager_controller_test.exs") refute File.exists?("phx_blog/lib/phx_blog_web/controllers/page_controller.ex") refute File.exists?("phx_blog/lib/phx_blog_web/controllers/page_html") refute File.exists?("phx_blog/lib/phx_blog_web/controllers/error_html.ex") refute File.exists?("phx_blog/lib/phx_blog_web/components") assert_file("phx_blog/mix.exs", &refute(&1 =~ ~r":phoenix_html")) assert_file("phx_blog/mix.exs", &refute(&1 =~ ~r":phoenix_live_reload")) assert_file("phx_blog/lib/phx_blog_web.ex", fn file -> refute file =~ "html_helpers" refute file =~ "Phoenix.HTML" refute file =~ "Phoenix.LiveView" end) assert_file("phx_blog/lib/phx_blog_web/endpoint.ex", fn file -> refute file =~ ~r"Phoenix.LiveReloader" refute file =~ ~r"Phoenix.LiveReloader.Socket" end) refute_file("phx_blog/lib/phx_blog_web/controllers/error_html.ex") assert_file("phx_blog/lib/phx_blog_web/controllers/error_json.ex") assert_file("phx_blog/lib/phx_blog_web/router.ex", &refute(&1 =~ ~r"pipeline :browser")) # No Dashboard assert_file("phx_blog/lib/phx_blog_web/endpoint.ex", fn file -> refute file =~ ~s|plug Phoenix.LiveDashboard.RequestLogger| end) assert_file("phx_blog/lib/phx_blog_web/router.ex", fn file -> refute file =~ "live_dashboard" refute file =~ "import Phoenix.LiveDashboard.Router" end) # No mailer or emails assert_file("phx_blog/mix.exs", fn file -> refute file =~ "{:swoosh" refute file =~ "{:req" end) refute File.exists?("phx_blog/lib/phx_blog/mailer.ex") assert_file("phx_blog/config/config.exs", fn file -> refute file =~ "config :swoosh" refute file =~ "config :phx_blog, PhxBlog.Mailer, adapter: Swoosh.Adapters.Local" end) assert_file("phx_blog/config/test.exs", fn file -> refute file =~ "config :swoosh" refute file =~ "config :phx_blog, PhxBlog.Mailer, adapter: Swoosh.Adapters.Test" end) assert_file("phx_blog/config/dev.exs", fn file -> refute file =~ "config :swoosh" end) assert_file("phx_blog/config/prod.exs", fn file -> refute file =~ "config :swoosh" end) end) end test "new with --no-dashboard" do in_tmp("new with no_dashboard", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-dashboard"]) assert_file("phx_blog/mix.exs", &refute(&1 =~ ~r":phoenix_live_dashboard")) assert_file("phx_blog/lib/phx_blog_web/endpoint.ex", fn file -> assert file =~ ~s|defmodule PhxBlogWeb.Endpoint| assert file =~ ~s| socket "/live"| refute file =~ ~s|plug Phoenix.LiveDashboard.RequestLogger| end) end) end test "new with --no-dashboard and --no-live" do in_tmp("new with no_dashboard and no_live", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-dashboard", "--no-live"]) assert_file("phx_blog/lib/phx_blog_web/endpoint.ex", fn file -> assert file =~ ~s|defmodule PhxBlogWeb.Endpoint| assert file =~ ~s|# socket "/live"| refute file =~ ~s|plug Phoenix.LiveDashboard.RequestLogger| end) end) end test "new with --no-html" do in_tmp("new with no_html", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-html"]) assert_file("phx_blog/mix.exs", fn file -> refute file =~ ~s|:phoenix_live_view| refute file =~ ~s|:phoenix_html| assert file =~ ~s|:phoenix_live_dashboard| end) assert_file("phx_blog/.formatter.exs", fn file -> assert file =~ "import_deps: [:ecto, :ecto_sql, :phoenix]" assert file =~ "subdirectories: [\"priv/*/migrations\"]" assert file =~ "inputs: [\"*.{ex,exs}\", \"{config,lib,test}/**/*.{ex,exs}\", \"priv/*/seeds.exs\"]" refute file =~ "plugins:" end) assert_file("phx_blog/lib/phx_blog_web/endpoint.ex", fn file -> assert file =~ ~s|defmodule PhxBlogWeb.Endpoint| assert file =~ ~s|socket "/live"| assert file =~ ~s|plug Phoenix.LiveDashboard.RequestLogger| end) assert_file("phx_blog/lib/phx_blog_web.ex", fn file -> refute file =~ ~s|Phoenix.HTML| refute file =~ ~s|Phoenix.LiveView| end) assert_file("phx_blog/lib/phx_blog_web/router.ex", fn file -> refute file =~ ~s|pipeline :browser| assert file =~ ~s|pipe_through [:fetch_session, :protect_from_forgery]| end) assert_file("phx_blog/config/config.exs", fn file -> refute file =~ ~s|config :phoenix_live_view| end) assert_file("phx_blog/config/test.exs", fn file -> refute file =~ ~s|config :phoenix_live_view| end) end) end test "new with --no-assets" do in_tmp("new no_assets", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-assets"]) assert_file("phx_blog/.gitignore", fn file -> refute file =~ "/priv/static/assets/" end) assert_file("phx_blog/.gitignore") assert_file("phx_blog/.gitignore", ~r/\n$/) assert_file("phx_blog/priv/static/assets/css/app.css") assert_file("phx_blog/priv/static/assets/js/app.js") assert_file("phx_blog/priv/static/favicon.ico") assert_file("phx_blog/config/config.exs", fn file -> refute file =~ "config :esbuild" end) assert_file("phx_blog/config/prod.exs", fn file -> refute file =~ "config :phx_blog, PhxBlogWeb.Endpoint, cache_static_manifest:" end) end) end test "new with --no-ecto" do in_tmp("new with no_ecto", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-ecto"]) assert_file("phx_blog/.formatter.exs", fn file -> assert file =~ "import_deps: [:phoenix]" assert file =~ "plugins: [Phoenix.LiveView.HTMLFormatter]" assert file =~ "inputs: [\"*.{heex,ex,exs}\", \"{config,lib,test}/**/*.{heex,ex,exs}\"]" refute file =~ "subdirectories:" end) end) end test "new with --no-gettext" do in_tmp("new with no_gettext", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-gettext"]) assert_file("phx_blog/lib/phx_blog_web/components/layouts.ex", fn file -> assert file =~ ~S|Attempting to reconnect| refute file =~ ~S|gettext("Attempting to reconnect")| end) assert_file("phx_blog/lib/phx_blog_web/components/core_components.ex", fn file -> assert file =~ ~S|aria-label="close"| refute file =~ ~S|gettext("close")| end) end) end test "new with binary_id" do in_tmp("new with binary_id", fn -> Mix.Tasks.Phx.New.run([@app_name, "--binary-id"]) assert_file("phx_blog/config/config.exs", ~r/generators: \[.*binary_id: true\.*]/) end) end test "new with path, app and module" do in_tmp("new with path, app and module", fn -> project_path = Path.join(File.cwd!(), "custom_path") Mix.Tasks.Phx.New.run([project_path, "--app", @app_name, "--module", "PhoteuxBlog"]) assert_file("custom_path/.gitignore") assert_file("custom_path/.gitignore", ~r/\n$/) assert_file("custom_path/mix.exs", ~r/app: :phx_blog/) assert_file("custom_path/lib/phx_blog_web/endpoint.ex", ~r/app: :phx_blog/) assert_file("custom_path/config/config.exs", ~r/namespace: PhoteuxBlog/) end) end test "new inside umbrella" do in_tmp("new inside umbrella", fn -> File.write!("mix.exs", MixHelper.umbrella_mixfile_contents()) File.mkdir!("apps") File.cd!("apps", fn -> Mix.Tasks.Phx.New.run([@app_name]) assert_file("phx_blog/mix.exs", fn file -> assert file =~ "deps_path: \"../../deps\"" assert file =~ "lockfile: \"../../mix.lock\"" end) refute_file("phx_blog/config/config.exs") end) assert_file("config/config.exs", fn file -> assert file =~ "PhxBlogWeb.Endpoint" assert file =~ ~s[cd: Path.expand("../apps/phx_blog/assets", __DIR__),] end) assert_file("config/config.exs", "PhxBlogWeb.Endpoint") end) end test "new with --no-install" do in_tmp("new with no install", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-install"]) # Does not prompt to install dependencies refute_received {:mix_shell, :yes?, ["\nFetch and install dependencies?"]} # Instructions assert_received {:mix_shell, :info, ["\nWe are almost there" <> _ = msg]} assert msg =~ "$ cd phx_blog" assert msg =~ "$ mix deps.get" assert_received {:mix_shell, :info, ["Then configure your database in config/dev.exs" <> _]} assert_received {:mix_shell, :info, ["Start your Phoenix app" <> _]} end) end test "new defaults to pg adapter" do in_tmp("new defaults to pg adapter", fn -> project_path = Path.join(File.cwd!(), "custom_path") Mix.Tasks.Phx.New.run([project_path]) assert_file("custom_path/mix.exs", ":postgrex") assert_file("custom_path/config/dev.exs", [ ~r/username: "postgres"/, ~r/password: "postgres"/, ~r/hostname: "localhost"/ ]) assert_file("custom_path/config/test.exs", [ ~r/username: "postgres"/, ~r/password: "postgres"/, ~r/hostname: "localhost"/ ]) assert_file("custom_path/config/runtime.exs", [~r/url: database_url/]) assert_file("custom_path/lib/custom_path/repo.ex", "Ecto.Adapters.Postgres") assert_file("custom_path/test/support/conn_case.ex", "DataCase.setup_sandbox(tags)") assert_file( "custom_path/test/support/data_case.ex", "Ecto.Adapters.SQL.Sandbox.start_owner" ) end) end test "new with mysql adapter" do in_tmp("new with mysql adapter", fn -> project_path = Path.join(File.cwd!(), "custom_path") Mix.Tasks.Phx.New.run([project_path, "--database", "mysql"]) assert_file("custom_path/mix.exs", ":myxql") assert_file("custom_path/config/dev.exs", [~r/username: "root"/, ~r/password: ""/]) assert_file("custom_path/config/test.exs", [~r/username: "root"/, ~r/password: ""/]) assert_file("custom_path/config/runtime.exs", [~r/url: database_url/]) assert_file("custom_path/lib/custom_path/repo.ex", "Ecto.Adapters.MyXQL") assert_file("custom_path/test/support/conn_case.ex", "DataCase.setup_sandbox(tags)") assert_file( "custom_path/test/support/data_case.ex", "Ecto.Adapters.SQL.Sandbox.start_owner" ) end) end test "new with sqlite3 adapter" do in_tmp("new with sqlite3 adapter", fn -> project_path = Path.join(File.cwd!(), "custom_path") Mix.Tasks.Phx.New.run([project_path, "--database", "sqlite3"]) assert_file("custom_path/mix.exs", ":ecto_sqlite3") assert_file("custom_path/config/dev.exs", [~r/database: .*_dev.db/]) assert_file("custom_path/config/test.exs", [~r/database: .*_test.db/]) assert_file("custom_path/config/runtime.exs", [~r/database: database_path/]) assert_file("custom_path/lib/custom_path/repo.ex", "Ecto.Adapters.SQLite3") assert_file("custom_path/lib/custom_path/application.ex", fn file -> assert file =~ "{Ecto.Migrator" assert file =~ "repos: Application.fetch_env!(:custom_path, :ecto_repos)" assert file =~ "skip: skip_migrations?()" assert file =~ "defp skip_migrations?() do" assert file =~ ~s/System.get_env("RELEASE_NAME") == nil/ end) assert_file("custom_path/test/support/conn_case.ex", "DataCase.setup_sandbox(tags)") assert_file( "custom_path/test/support/data_case.ex", "Ecto.Adapters.SQL.Sandbox.start_owner" ) assert_file("custom_path/.gitignore", "*.db") assert_file("custom_path/.gitignore", "*.db-*") end) end test "new with mssql adapter" do in_tmp("new with mssql adapter", fn -> project_path = Path.join(File.cwd!(), "custom_path") Mix.Tasks.Phx.New.run([project_path, "--database", "mssql"]) assert_file("custom_path/mix.exs", ":tds") assert_file("custom_path/config/dev.exs", [ ~r/username: "sa"/, ~r/password: "some!Password"/ ]) assert_file("custom_path/config/test.exs", [ ~r/username: "sa"/, ~r/password: "some!Password"/ ]) assert_file("custom_path/config/runtime.exs", [~r/url: database_url/]) assert_file("custom_path/lib/custom_path/repo.ex", "Ecto.Adapters.Tds") assert_file("custom_path/test/support/conn_case.ex", "DataCase.setup_sandbox(tags)") assert_file( "custom_path/test/support/data_case.ex", "Ecto.Adapters.SQL.Sandbox.start_owner" ) end) end test "new with invalid database adapter" do in_tmp("new with invalid database adapter", fn -> project_path = Path.join(File.cwd!(), "custom_path") assert_raise Mix.Error, ~s(Unknown database "invalid"), fn -> Mix.Tasks.Phx.New.run([project_path, "--database", "invalid"]) end end) end test "new with bandit web adapter" do in_tmp("new with bandit web adapter", fn -> project_path = Path.join(File.cwd!(), "custom_path") Mix.Tasks.Phx.New.run([project_path, "--adapter", "bandit"]) assert_file("custom_path/mix.exs", ":bandit") assert_file("custom_path/config/config.exs", "adapter: Bandit.PhoenixAdapter") end) end test "new with invalid args" do assert_raise Mix.Error, ~r"Application name must start with a letter and ", fn -> Mix.Tasks.Phx.New.run(["007invalid"]) end assert_raise Mix.Error, ~r"Application name must start with a letter and ", fn -> Mix.Tasks.Phx.New.run(["valid", "--app", "007invalid"]) end assert_raise Mix.Error, ~r"Application name must start with a letter and ", fn -> Mix.Tasks.Phx.New.run(["exInvalidAppName"]) end assert_raise Mix.Error, ~r"Module name must be a valid Elixir alias", fn -> Mix.Tasks.Phx.New.run(["valid", "--module", "not.valid"]) end assert_raise Mix.Error, ~r"Module name \w+ is already taken", fn -> Mix.Tasks.Phx.New.run(["string"]) end assert_raise Mix.Error, ~r"Module name \w+ is already taken", fn -> Mix.Tasks.Phx.New.run(["valid", "--app", "mix"]) end assert_raise Mix.Error, ~r"Module name \w+ is already taken", fn -> Mix.Tasks.Phx.New.run(["valid", "--module", "String"]) end end test "invalid options" do assert_raise OptionParser.ParseError, fn -> Mix.Tasks.Phx.New.run(["valid", "-database", "mysql"]) end end test "new without args" do in_tmp("new without args", fn -> assert capture_io(fn -> Mix.Tasks.Phx.New.run([]) end) =~ "Creates a new Phoenix project." end) end test "new with reserved name" do assert_raise Mix.Error, ~r/Application name cannot be "server" as it is reserved/, fn -> Mix.Tasks.Phx.New.run(["server"]) end assert_raise Mix.Error, ~r/Application name cannot be "table" as it is reserved/, fn -> Mix.Tasks.Phx.New.run(["table"]) end end test "new from inside docker machine (simulated)" do in_tmp("new without defaults", fn -> Mix.Tasks.Phx.New.run([@app_name, "--inside-docker-env"]) assert_file("phx_blog/config/dev.exs", fn file -> assert file =~ "http: [ip: {0, 0, 0, 0}" end) end) end test "new with --no-agents-md" do in_tmp("new with no agents md", fn -> Mix.Tasks.Phx.New.run([@app_name, "--no-agents-md"]) refute_file("phx_blog/AGENTS.md") end) end describe "PHX_NEW_CACHE_DIR" do @phx_new_cache_dir System.get_env("PHX_NEW_CACHE_DIR") test "new with PHX_NEW_CACHE_DIR" do System.put_env("PHX_NEW_CACHE_DIR", __DIR__) cache_files = File.ls!(__DIR__) in_tmp("new with cache dir", fn -> Mix.Tasks.Phx.New.run([@app_name]) project_files = File.ls!(Path.join(File.cwd!(), @app_name)) assert "mix.exs" in project_files for file <- cache_files do assert file in project_files, "#{file} not copied to new project" end end) after if @phx_new_cache_dir do System.put_env("PHX_NEW_CACHE_DIR", @phx_new_cache_dir) else System.delete_env("PHX_NEW_CACHE_DIR") end end test "new with PHX_NEW_CACHE_DIR that doesn't exist" do cache_dir = Path.join(__DIR__, "does-not-exist") System.put_env("PHX_NEW_CACHE_DIR", cache_dir) refute File.exists?(cache_dir) in_tmp("new with cache dir", fn -> Mix.Tasks.Phx.New.run([@app_name]) project_files = File.ls!(Path.join(File.cwd!(), @app_name)) assert "mix.exs" in project_files end) after if @phx_new_cache_dir do System.put_env("PHX_NEW_CACHE_DIR", @phx_new_cache_dir) else System.delete_env("PHX_NEW_CACHE_DIR") end end end end ================================================ FILE: installer/test/phx_new_umbrella_test.exs ================================================ Code.require_file("mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.New.UmbrellaTest do use ExUnit.Case, async: false import MixHelper @app "phx_umb" setup config do # The shell asks to install deps. # We will politely say not. decline_prompt() {:ok, tmp_dir: to_string(config.test)} end defp decline_prompt do send(self(), {:mix_shell_input, :yes?, false}) end defp root_path(app, path \\ "") do Path.join(["#{app}_umbrella", path]) end defp app_path(app, path) do Path.join(["#{app}_umbrella/apps/#{app}", path]) end defp web_path(app, path) do Path.join(["#{app}_umbrella/apps/#{app}_web", path]) end test "new with umbrella and defaults" do in_tmp("new with umbrella and defaults", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella"]) assert_file(root_path(@app, "README.md")) assert_file(root_path(@app, "AGENTS.md")) assert_file(root_path(@app, ".gitignore")) assert_file(app_path(@app, "README.md")) assert_file(app_path(@app, ".gitignore"), "#{@app}-*.tar") assert_file(web_path(@app, "README.md")) assert_file(root_path(@app, "mix.exs"), fn file -> assert file =~ "apps_path: \"apps\"" end) # Phoenix.LiveView.HTMLFormatter assert_file(root_path(@app, "mix.exs"), fn file -> assert file =~ "{:phoenix_live_view, \">= 0.0.0\"}" end) assert_file(app_path(@app, "mix.exs"), fn file -> assert file =~ "app: :phx_umb" assert file =~ ~S{build_path: "../../_build"} assert file =~ ~S{config_path: "../../config/config.exs"} assert file =~ ~S{deps_path: "../../deps"} assert file =~ ~S{lockfile: "../../mix.lock"} end) assert_file(root_path(@app, "config/config.exs"), fn file -> assert file =~ ~r/config :esbuild/ assert file =~ "cd: Path.expand(\"../apps/phx_umb_web/assets\", __DIR__)" assert file =~ ~S[import_config "#{config_env()}.exs"] assert file =~ "config :phoenix, :json_library, Jason" assert file =~ "ecto_repos: [PhxUmb.Repo]" assert file =~ ":phx_umb_web, PhxUmbWeb.Endpoint" assert file =~ "generators: [context_app: :phx_umb]\n" refute file =~ "namespace" end) assert_file(root_path(@app, "config/dev.exs"), fn file -> assert file =~ ~r[esbuild: {Esbuild] assert file =~ "lib/#{@app}_web/router\\.ex$" assert file =~ "lib/#{@app}_web/(controllers|live|components)/.*\\.(ex|heex)$" assert file =~ "config :#{@app}_web, dev_routes: true" end) assert_file(root_path(@app, "config/prod.exs"), fn file -> assert file =~ "port: 80" end) assert_file(root_path(@app, "config/runtime.exs"), fn file -> assert file =~ ~r/^\s+config :phx_umb_web, PhxUmbWeb.Endpoint,\n\s+http: \[port: String\.to_integer\(System\.get_env\("PORT", "4000"\)\)\]$/m assert file =~ ~r/^\s+ip: {0, 0, 0, 0, 0, 0, 0, 0}$/m end) assert_file(root_path(@app, ".formatter.exs"), fn file -> assert file =~ "plugins: [Phoenix.LiveView.HTMLFormatter]" assert file =~ "inputs: [\"mix.exs\", \"config/*.exs\"]" assert file =~ "subdirectories: [\"apps/*\"]" end) assert_file(app_path(@app, ".formatter.exs"), fn file -> assert file =~ "import_deps: [:ecto, :ecto_sql]" assert file =~ "subdirectories: [\"priv/*/migrations\"]" assert file =~ "plugins: [Phoenix.LiveView.HTMLFormatter]" assert file =~ "inputs: [\"*.{heex,ex,exs}\", \"{config,lib,test}/**/*.{heex,ex,exs}\", \"priv/*/seeds.exs\"]" end) assert_file(web_path(@app, ".formatter.exs"), fn file -> assert file =~ "import_deps: [:phoenix]" assert file =~ "plugins: [Phoenix.LiveView.HTMLFormatter]" assert file =~ "inputs: [\"*.{heex,ex,exs}\", \"{config,lib,test}/**/*.{heex,ex,exs}\"]" refute file =~ "import_deps: [:ecto]" refute file =~ "subdirectories:" end) assert_file( app_path(@app, "lib/#{@app}/application.ex"), ~r/defmodule PhxUmb.Application do/ ) assert_file(app_path(@app, "lib/#{@app}/application.ex"), ~r/PhxUmb.Repo/) assert_file(app_path(@app, "lib/#{@app}.ex"), ~r/defmodule PhxUmb do/) assert_file(app_path(@app, "mix.exs"), fn file -> assert file =~ "mod: {PhxUmb.Application, []}" assert file =~ "{:phoenix_pubsub, \"~> 2.1\"}" end) assert_file(app_path(@app, "test/test_helper.exs")) assert_file( web_path(@app, "lib/#{@app}_web/application.ex"), ~r/defmodule PhxUmbWeb.Application do/ ) assert_file(web_path(@app, "mix.exs"), fn file -> assert file =~ "mod: {PhxUmbWeb.Application, []}" assert file =~ "{:jason" end) assert_file(web_path(@app, "lib/#{@app}_web.ex"), fn file -> assert file =~ "defmodule PhxUmbWeb do" assert file =~ "import Phoenix.HTML" assert file =~ "Phoenix.LiveView" end) assert_file( web_path(@app, "lib/#{@app}_web/endpoint.ex"), ~r/defmodule PhxUmbWeb.Endpoint do/ ) assert_file(web_path(@app, "test/#{@app}_web/controllers/page_controller_test.exs")) assert_file(web_path(@app, "test/#{@app}_web/controllers/error_html_test.exs")) assert_file(web_path(@app, "test/#{@app}_web/controllers/error_json_test.exs")) assert_file(web_path(@app, "test/support/conn_case.ex")) assert_file(web_path(@app, "test/test_helper.exs")) assert_file( web_path(@app, "lib/#{@app}_web/controllers/page_controller.ex"), ~r/defmodule PhxUmbWeb.PageController/ ) assert_file( web_path(@app, "lib/#{@app}_web/controllers/page_html.ex"), ~r/defmodule PhxUmbWeb.PageHTML/ ) assert_file(web_path(@app, "lib/#{@app}_web/router.ex"), fn file -> assert file =~ "defmodule PhxUmbWeb.Router" assert file =~ "Application.compile_env(:#{@app}_web, :dev_routes)" end) assert_file( web_path(@app, "lib/#{@app}_web/components/core_components.ex"), "defmodule PhxUmbWeb.CoreComponents" ) assert_file( web_path(@app, "lib/#{@app}_web/components/layouts.ex"), "defmodule PhxUmbWeb.Layouts" ) assert_file(web_path(@app, "lib/#{@app}_web/components/layouts/root.html.heex"), fn file -> assert file =~ ~s|| end) # assets assert_file(web_path(@app, ".gitignore"), "/priv/static/assets/") assert_file(web_path(@app, ".gitignore"), "#{@app}_web-*.tar") assert_file(web_path(@app, ".gitignore"), ~r/\n$/) assert_file(web_path(@app, "assets/css/app.css"), fn file -> assert file =~ "lib/phx_umb_web" end) assert_file(web_path(@app, "priv/static/favicon.ico")) refute File.exists?(web_path(@app, "priv/static/assets/css/app.css")) refute File.exists?(web_path(@app, "priv/static/assets/js/app.js")) assert File.exists?(web_path(@app, "assets/vendor")) # web deps assert_file(web_path(@app, "mix.exs"), fn file -> assert file =~ "{:phx_umb, in_umbrella: true}" assert file =~ "{:phoenix," assert file =~ "{:phoenix_live_view," assert file =~ "{:gettext," assert file =~ "{:bandit," end) # app deps assert_file(web_path(@app, "mix.exs"), fn file -> assert file =~ "{:phoenix_ecto," assert file =~ "{:jason," end) # Ecto config = ~r/config :phx_umb, PhxUmb.Repo,/ assert_file(root_path(@app, "config/dev.exs"), config) assert_file(root_path(@app, "config/test.exs"), config) assert_file(root_path(@app, "config/runtime.exs"), config) assert_file(app_path(@app, "mix.exs"), fn file -> assert file =~ "aliases: aliases()" assert file =~ "ecto.setup" assert file =~ "ecto.reset" assert file =~ "{:jason," end) assert_file(app_path(@app, "lib/#{@app}/repo.ex"), ~r"defmodule PhxUmb.Repo") assert_file(app_path(@app, "priv/repo/seeds.exs"), ~r"PhxUmb.Repo.insert!") assert_file(app_path(@app, "test/support/data_case.ex"), ~r"defmodule PhxUmb.DataCase") assert_file( app_path(@app, "priv/repo/migrations/.formatter.exs"), ~r"import_deps: \[:ecto_sql\]" ) # Telemetry assert_file(web_path(@app, "mix.exs"), fn file -> assert file =~ "{:telemetry_metrics," assert file =~ "{:telemetry_poller," end) assert_file(web_path(@app, "lib/#{@app}_web/telemetry.ex"), fn file -> assert file =~ "defmodule PhxUmbWeb.Telemetry do" assert file =~ "{:telemetry_poller, measurements: periodic_measurements()" assert file =~ "defp periodic_measurements do" assert file =~ "# {PhxUmbWeb, :count_users, []}" assert file =~ "def metrics do" assert file =~ "summary(\"phoenix.endpoint.stop.duration\"," assert file =~ "summary(\"phoenix.router_dispatch.stop.duration\"," assert file =~ "# Database Metrics" assert file =~ "summary(\"phx_umb.repo.query.total_time\"," end) # Live assert_file(web_path(@app, "assets/js/app.js"), fn file -> assert file =~ ~s[import {LiveSocket} from "phoenix_live_view"] end) assert_file(root_path(@app, "config/config.exs"), fn file -> assert file =~ "live_view:" assert file =~ "signing_salt:" end) assert_file(web_path(@app, "lib/#{@app}_web.ex"), fn file -> assert file =~ "def live_view do" assert file =~ "def live_component do" end) assert_file( web_path(@app, "lib/phx_umb_web/endpoint.ex"), ~s[socket "/live", Phoenix.LiveView.Socket] ) assert_file(web_path(@app, "lib/phx_umb_web/router.ex"), fn file -> assert file =~ ~s[plug :fetch_live_flash] assert file =~ ~s[plug :put_root_layout, html: {PhxUmbWeb.Layouts, :root}] assert file =~ ~s[get "/", PageController] end) # Mailer assert_file(app_path(@app, "mix.exs"), fn file -> assert file =~ "{:swoosh, \"~> 1.16\"}" assert file =~ "{:req, \"~> 0.5\"}" end) assert_file(app_path(@app, "lib/#{@app}/mailer.ex"), fn file -> assert file =~ "defmodule PhxUmb.Mailer do" assert file =~ "use Swoosh.Mailer, otp_app: :phx_umb" end) assert_file(root_path(@app, "config/config.exs"), fn file -> assert file =~ "config :phx_umb, PhxUmb.Mailer, adapter: Swoosh.Adapters.Local" end) assert_file(root_path(@app, "config/test.exs"), fn file -> assert file =~ "config :swoosh" assert file =~ "config :phx_umb, PhxUmb.Mailer, adapter: Swoosh.Adapters.Test" end) assert_file(root_path(@app, "config/dev.exs"), fn file -> assert file =~ "config :swoosh" end) assert_file(root_path(@app, "config/prod.exs"), fn file -> assert file =~ "config :swoosh, :api_client, Swoosh.ApiClient.Req" end) # Install dependencies? assert_received {:mix_shell, :yes?, ["\nFetch and install dependencies?"]} # Instructions assert_received {:mix_shell, :info, ["\nWe are almost there" <> _ = msg]} assert msg =~ "$ cd phx_umb" assert msg =~ "$ mix deps.get" assert_received {:mix_shell, :info, ["Then configure your database in config/dev.exs" <> _]} assert_received {:mix_shell, :info, ["Start your Phoenix app" <> _]} # Gettext assert_file(web_path(@app, "lib/#{@app}_web/gettext.ex"), [ ~r"defmodule PhxUmbWeb.Gettext", ~r"use Gettext\.Backend, otp_app: :phx_umb_web" ]) assert File.exists?(web_path(@app, "priv/gettext/errors.pot")) assert File.exists?(web_path(@app, "priv/gettext/en/LC_MESSAGES/errors.po")) end) end test "new without defaults" do in_tmp("new without defaults", fn -> Mix.Tasks.Phx.New.run([ @app, "--umbrella", "--no-html", "--no-assets", "--no-ecto", "--no-live", "--no-mailer" ]) # No assets assert_file(web_path(@app, ".gitignore"), fn file -> assert file =~ ~r/\n$/ refute file =~ "/priv/static/assets/" end) assert_file(root_path(@app, "config/dev.exs"), ~r/watchers: \[\]/) # No assets & No HTML refute_file(web_path(@app, "priv/static/assets/js/app.js")) refute_file(web_path(@app, "priv/static/assets/css/app.css")) # No Ecto config = ~r/config :phx_umb, PhxUmb.Repo,/ refute File.exists?(app_path(@app, "lib/#{@app}_web/repo.ex")) assert_file(app_path(@app, "mix.exs"), &refute(&1 =~ ~r":phoenix_ecto")) assert_file(root_path(@app, "config/config.exs"), fn file -> refute file =~ "config :esbuild" refute file =~ "config :phx_blog_web, :generators" refute file =~ "ecto_repos:" end) assert_file(web_path(@app, "lib/#{@app}_web/telemetry.ex"), fn file -> refute file =~ "# Database Metrics" refute file =~ "summary(\"phx_umb.repo.query.total_time\"," end) assert_file(root_path(@app, "config/dev.exs"), &refute(&1 =~ config)) assert_file(root_path(@app, "config/test.exs"), &refute(&1 =~ config)) assert_file(root_path(@app, "config/runtime.exs"), &refute(&1 =~ config)) assert_file(app_path(@app, "lib/#{@app}/application.ex"), ~r/Supervisor.start_link\(/) # No LiveView (in web_path) assert_file(web_path(@app, "mix.exs"), &refute(&1 =~ ~r":phoenix_live_view")) assert_file(web_path(@app, "mix.exs"), &refute(&1 =~ ~r":lazy_html")) refute File.exists?(web_path(@app, "lib/#{@app}_web/templates/page/hero.html.heex")) refute_file(web_path(@app, "assets/js/live.js")) # No HTML assert File.exists?(web_path(@app, "test/#{@app}_web/controllers")) refute File.exists?(web_path(@app, "test/#{@app}_web/controllers/error_html_test.exs")) assert File.exists?(web_path(@app, "lib/#{@app}_web/controllers")) refute File.exists?(web_path(@app, "test/controllers/page_controller_test.exs")) refute File.exists?(web_path(@app, "lib/#{@app}_web/controllers/page_controller.ex")) refute File.exists?(web_path(@app, "lib/#{@app}_web/controllers/error_html.ex")) refute File.exists?(web_path(@app, "lib/#{@app}_web/controllers/page_html.ex")) refute File.exists?(web_path(@app, "lib/#{@app}_web/controllers/page_html")) refute File.exists?(web_path(@app, "lib/#{@app}_web/components")) assert_file(web_path(@app, "mix.exs"), &refute(&1 =~ ~r":phoenix_html")) assert_file(web_path(@app, "mix.exs"), &refute(&1 =~ ~r":phoenix_live_reload")) assert_file(web_path(@app, "lib/#{@app}_web.ex"), fn file -> refute file =~ "defp html_helpers do" refute file =~ "Phoenix.HTML" refute file =~ "Phoenix.LiveView" end) assert_file(web_path(@app, "lib/#{@app}_web/endpoint.ex"), fn file -> refute file =~ ~r"Phoenix.LiveReloader" refute file =~ ~r"Phoenix.LiveReloader.Socket" end) assert_file(web_path(@app, "lib/#{@app}_web/controllers/error_json.ex"), ~r".json") assert_file( web_path(@app, "lib/#{@app}_web/router.ex"), &refute(&1 =~ ~r"pipeline :browser") ) # Without mailer assert_file(web_path(@app, "mix.exs"), fn file -> refute file =~ "{:swoosh" refute file =~ "{:req" end) refute File.exists?(app_path(@app, "lib/#{@app}/mailer.ex")) assert_file(root_path(@app, "config/config.exs"), fn file -> refute file =~ "config :swoosh" refute file =~ "config :phx_umb, PhxUmb.Mailer, adapter: Swoosh.Adapters.Local" end) assert_file(root_path(@app, "config/test.exs"), fn file -> refute file =~ "config :phx_umb, PhxUmb.Mailer, adapter: Swoosh.Adapters.Test" end) assert_file(root_path(@app, "config/prod.exs"), fn file -> refute file =~ "config :swoosh" end) end) end test "new with --no-dashboard" do in_tmp("new with no_dashboard", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella", "--no-dashboard"]) assert_file(web_path(@app, "mix.exs"), &refute(&1 =~ ~r":phoenix_live_dashboard")) assert_file(web_path(@app, "lib/#{@app}_web/endpoint.ex"), fn file -> assert file =~ ~s|defmodule PhxUmbWeb.Endpoint| assert file =~ ~s|socket "/live"| refute file =~ ~s|plug Phoenix.LiveDashboard.RequestLogger| end) end) end test "new with --no-dashboard and --no-live" do in_tmp("new with no_dashboard and no_live", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella", "--no-dashboard", "--no-live"]) assert_file(web_path(@app, "lib/#{@app}_web/endpoint.ex"), fn file -> assert file =~ ~s|# socket "/live"| end) assert_file(web_path(@app, "assets/js/app.js"), fn file -> assert file =~ ~s|// import {Socket} from "phoenix"| assert file =~ ~s|// import {LiveSocket} from "phoenix_live_view"| assert file =~ ~s|// import topbar from "../vendor/topbar"| assert file =~ ~s|// liveSocket.connect()| end) end) end test "new with --no-html" do in_tmp("new with no_html", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella", "--no-html"]) assert_file(root_path(@app, "mix.exs"), fn file -> assert file =~ "defp deps do\n []" end) refute_file(web_path(@app, "test/#{@app}_web/controllers/error_html_test.exs")) assert_file(web_path(@app, "mix.exs"), fn file -> refute file =~ ~s|:phoenix_live_view| assert file =~ ~s|:phoenix_live_dashboard| end) assert_file(web_path(@app, "lib/#{@app}_web/endpoint.ex"), fn file -> assert file =~ ~s|defmodule PhxUmbWeb.Endpoint| assert file =~ ~s|socket "/live"| assert file =~ ~s|plug Phoenix.LiveDashboard.RequestLogger| end) assert_file(web_path(@app, "lib/#{@app}_web.ex"), fn file -> refute file =~ ~s|Phoenix.HTML| refute file =~ ~s|Phoenix.LiveView| end) assert_file(web_path(@app, "lib/#{@app}_web/router.ex"), fn file -> refute file =~ ~s|pipeline :browser| assert file =~ ~s|pipe_through [:fetch_session, :protect_from_forgery]| end) end) end test "new with --no-assets" do in_tmp("new with no_assets", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella", "--no-assets"]) refute File.read!(web_path(@app, ".gitignore")) |> String.contains?("/priv/static/assets/") assert_file(web_path(@app, ".gitignore"), ~r/\n$/) assert_file(web_path(@app, "priv/static/assets/js/app.js")) assert_file(web_path(@app, "priv/static/assets/css/app.css")) assert_file(web_path(@app, "priv/static/favicon.ico")) end) end test "new with binary_id" do in_tmp("new with binary_id", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella", "--binary-id"]) assert_file( root_path(@app, "config/config.exs"), ~r/generators: \[context_app: :phx_umb, binary_id: true\]/ ) end) end test "new with path, app and module" do in_tmp("new with path, app and module", fn -> project_path = Path.join(File.cwd!(), "custom_path") Mix.Tasks.Phx.New.run([ project_path, "--umbrella", "--app", @app, "--module", "PhoteuxBlog" ]) assert_file("custom_path_umbrella/apps/phx_umb/mix.exs", ~r/app: :phx_umb/) assert_file( "custom_path_umbrella/apps/phx_umb_web/lib/phx_umb_web/endpoint.ex", ~r/app: :#{@app}_web/ ) assert_file( "custom_path_umbrella/apps/phx_umb/lib/phx_umb/application.ex", ~r/defmodule PhoteuxBlog.Application/ ) assert_file( "custom_path_umbrella/apps/phx_umb/mix.exs", ~r/mod: {PhoteuxBlog.Application, \[\]}/ ) assert_file( "custom_path_umbrella/apps/phx_umb_web/lib/phx_umb_web/application.ex", ~r/defmodule PhoteuxBlogWeb.Application/ ) assert_file( "custom_path_umbrella/apps/phx_umb_web/mix.exs", ~r/mod: {PhoteuxBlogWeb.Application, \[\]}/ ) assert_file("custom_path_umbrella/config/config.exs", ~r/namespace: PhoteuxBlogWeb/) assert_file("custom_path_umbrella/config/config.exs", ~r/namespace: PhoteuxBlog/) end) end test "new inside umbrella" do in_tmp("new inside umbrella", fn -> File.write!("mix.exs", MixHelper.umbrella_mixfile_contents()) File.mkdir!("apps") File.cd!("apps", fn -> assert_raise Mix.Error, "Unable to nest umbrella project within apps", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella"]) end end) end) end test "new defaults to pg adapter" do in_tmp("new defaults to pg adapter", fn -> app = "custom_path" project_path = Path.join(File.cwd!(), app) Mix.Tasks.Phx.New.run([project_path, "--umbrella"]) assert_file(app_path(app, "mix.exs"), ":postgrex") assert_file(app_path(app, "lib/custom_path/repo.ex"), "Ecto.Adapters.Postgres") assert_file(root_path(app, "config/dev.exs"), [ ~r/username: "postgres"/, ~r/password: "postgres"/, ~r/hostname: "localhost"/ ]) assert_file(root_path(app, "config/test.exs"), [ ~r/username: "postgres"/, ~r/password: "postgres"/, ~r/hostname: "localhost"/ ]) assert_file(root_path(app, "config/runtime.exs"), [~r/url: database_url/]) assert_file(web_path(app, "test/support/conn_case.ex"), "DataCase.setup_sandbox(tags)") end) end test "new with mysql adapter" do in_tmp("new with mysql adapter", fn -> app = "custom_path" project_path = Path.join(File.cwd!(), app) Mix.Tasks.Phx.New.run([project_path, "--umbrella", "--database", "mysql"]) assert_file(app_path(app, "mix.exs"), ":myxql") assert_file(app_path(app, "lib/custom_path/repo.ex"), "Ecto.Adapters.MyXQL") assert_file(root_path(app, "config/dev.exs"), [~r/username: "root"/, ~r/password: ""/]) assert_file(root_path(app, "config/test.exs"), [~r/username: "root"/, ~r/password: ""/]) assert_file(root_path(app, "config/runtime.exs"), [~r/url: database_url/]) assert_file(web_path(app, "test/support/conn_case.ex"), "DataCase.setup_sandbox(tags)") end) end test "new with sqlite3 adapter" do in_tmp("new with sqlite3 adapter", fn -> app = "custom_path" project_path = Path.join(File.cwd!(), app) Mix.Tasks.Phx.New.run([project_path, "--umbrella", "--database", "sqlite3"]) assert_file(app_path(app, "mix.exs"), ":ecto_sqlite3") assert_file(app_path(app, "lib/custom_path/repo.ex"), "Ecto.Adapters.SQLite3") assert_file(app_path(app, "lib/custom_path/application.ex"), fn file -> assert file =~ "{Ecto.Migrator" assert file =~ "repos: Application.fetch_env!(:custom_path, :ecto_repos)" assert file =~ "skip: skip_migrations?()" assert file =~ "defp skip_migrations?() do" assert file =~ ~s/System.get_env("RELEASE_NAME") == nil/ end) assert_file(root_path(app, "config/dev.exs"), [~r/database: .*_dev.db/]) assert_file(root_path(app, "config/test.exs"), [~r/database: .*_test.db/]) assert_file(root_path(app, "config/runtime.exs"), [~r/database: database_path/]) assert_file(web_path(app, "test/support/conn_case.ex"), "DataCase.setup_sandbox(tags)") assert_file(root_path(app, ".gitignore"), "*.db") assert_file(root_path(app, ".gitignore"), "*.db-*") end) end test "new with mssql adapter" do in_tmp("new with mssql adapter", fn -> app = "custom_path" project_path = Path.join(File.cwd!(), app) Mix.Tasks.Phx.New.run([project_path, "--umbrella", "--database", "mssql"]) assert_file(app_path(app, "mix.exs"), ":tds") assert_file(app_path(app, "lib/custom_path/repo.ex"), "Ecto.Adapters.Tds") assert_file(root_path(app, "config/dev.exs"), [ ~r/username: "sa"/, ~r/password: "some!Password"/ ]) assert_file(root_path(app, "config/test.exs"), [ ~r/username: "sa"/, ~r/password: "some!Password"/ ]) assert_file(root_path(app, "config/runtime.exs"), [~r/url: database_url/]) assert_file(web_path(app, "test/support/conn_case.ex"), "DataCase.setup_sandbox(tags)") end) end test "new with invalid database adapter" do in_tmp("new with invalid database adapter", fn -> project_path = Path.join(File.cwd!(), "custom_path") assert_raise Mix.Error, ~s(Unknown database "invalid"), fn -> Mix.Tasks.Phx.New.run([project_path, "--umbrella", "--database", "invalid"]) end end) end test "new with cowboy web adapter" do in_tmp("new with cowboy web adapter", fn -> app = "custom_path" project_path = Path.join(File.cwd!(), app) Mix.Tasks.Phx.New.run([project_path, "--umbrella", "--adapter", "cowboy"]) assert_file(web_path(app, "mix.exs"), ":plug_cowboy") assert_file(root_path(app, "config/config.exs"), "adapter: Phoenix.Endpoint.Cowboy2Adapter") end) end test "new with invalid args" do assert_raise Mix.Error, ~r"Application name must start with a letter and ", fn -> Mix.Tasks.Phx.New.run(["007invalid", "--umbrella"]) end assert_raise Mix.Error, ~r"Application name must start with a letter and ", fn -> Mix.Tasks.Phx.New.run(["valid1", "--app", "007invalid", "--umbrella"]) end assert_raise Mix.Error, ~r"Application name must start with a letter and ", fn -> Mix.Tasks.Phx.New.run(["valid1", "--app", "exInvalidAppAnme", "--umbrella"]) end assert_raise Mix.Error, ~r"Module name must be a valid Elixir alias", fn -> Mix.Tasks.Phx.New.run(["valid2", "--module", "not.valid", "--umbrella"]) end assert_raise Mix.Error, ~r"Module name \w+ is already taken", fn -> Mix.Tasks.Phx.New.run(["string", "--umbrella"]) end assert_raise Mix.Error, ~r"Module name \w+ is already taken", fn -> Mix.Tasks.Phx.New.run(["valid3", "--app", "mix", "--umbrella"]) end assert_raise Mix.Error, ~r"Module name \w+ is already taken", fn -> Mix.Tasks.Phx.New.run(["valid4", "--module", "String", "--umbrella"]) end end test "invalid options" do assert_raise OptionParser.ParseError, fn -> Mix.Tasks.Phx.New.run(["valid5", "-database", "mysql", "--umbrella"]) end end test "umbrella with --no-agents-md" do in_tmp("umbrella with no agents md", fn -> Mix.Tasks.Phx.New.run([@app, "--umbrella", "--no-agents-md"]) refute_file(root_path(@app, "AGENTS.md")) end) end describe "ecto task" do test "can only be run within an umbrella app dir", %{tmp_dir: tmp_dir} do in_tmp(tmp_dir, fn -> cwd = File.cwd!() umbrella_path = root_path(@app) Mix.Tasks.Phx.New.run([@app, "--umbrella"]) flush() for dir <- [cwd, umbrella_path] do File.cd!(dir, fn -> assert_raise Mix.Error, ~r"The ecto task can only be run within an umbrella's apps directory", fn -> Mix.Tasks.Phx.New.Ecto.run(["valid"]) end end) end end) end end describe "web task" do test "can only be run within an umbrella app dir", %{tmp_dir: tmp_dir} do in_tmp(tmp_dir, fn -> cwd = File.cwd!() umbrella_path = root_path(@app) Mix.Tasks.Phx.New.run([@app, "--umbrella"]) flush() for dir <- [cwd, umbrella_path] do File.cd!(dir, fn -> assert_raise Mix.Error, ~r"The web task can only be run within an umbrella's apps directory", fn -> Mix.Tasks.Phx.New.Web.run(["valid"]) end end) end end) end test "generates web-only files", %{tmp_dir: tmp_dir} do in_tmp(tmp_dir, fn -> umbrella_path = root_path(@app) Mix.Tasks.Phx.New.run([@app, "--umbrella"]) flush() File.cd!(Path.join(umbrella_path, "apps")) decline_prompt() Mix.Tasks.Phx.New.Web.run(["another"]) assert_file("another/README.md") assert_file("another/mix.exs", fn file -> assert file =~ "app: :another" assert file =~ "deps_path: \"../../deps\"" assert file =~ "lockfile: \"../../mix.lock\"" end) assert_file("../config/config.exs", fn file -> assert file =~ "ecto_repos: [Another.Repo]" end) assert_file("../config/prod.exs", fn file -> assert file =~ "port: 80" end) assert_file("../config/runtime.exs", ~r/ip: {0, 0, 0, 0, 0, 0, 0, 0}/) assert_file("another/lib/another/application.ex", ~r/defmodule Another.Application do/) assert_file("another/mix.exs", ~r/mod: {Another.Application, \[\]}/) assert_file("another/lib/another.ex", ~r/defmodule Another do/) assert_file("another/lib/another/endpoint.ex", ~r/defmodule Another.Endpoint do/) assert_file("another/test/another/controllers/page_controller_test.exs") assert_file("another/test/another/controllers/error_html_test.exs") assert_file("another/test/another/controllers/error_json_test.exs") assert_file("another/test/support/conn_case.ex") assert_file("another/test/test_helper.exs") assert_file( "another/lib/another/controllers/page_controller.ex", ~r/defmodule Another.PageController/ ) assert File.dir?("another/lib/another/controllers/page_html") assert_file( "another/lib/another/controllers/page_html.ex", ~r/defmodule Another.PageHTML/ ) assert_file("another/lib/another/router.ex", "defmodule Another.Router") assert_file("another/lib/another.ex", "defmodule Another") assert_file("another/lib/another/components/layouts/root.html.heex") # assets assert_file("another/.gitignore", ~r/\n$/) assert_file("another/priv/static/favicon.ico") assert_file("another/assets/css/app.css") refute File.exists?("another/priv/static/assets/css/app.css") refute File.exists?("another/priv/static/assets/js/app.js") assert File.exists?("another/assets/vendor") # Ecto assert_file("another/mix.exs", fn file -> assert file =~ "{:phoenix_ecto," end) assert_file("another/lib/another.ex", ~r"defmodule Another") refute_file("another/lib/another/repo.ex") refute_file("another/priv/repo/seeds.exs") refute_file("another/test/support/data_case.ex") # Install dependencies? assert_received {:mix_shell, :yes?, ["\nFetch and install dependencies?"]} # Instructions assert_received {:mix_shell, :info, ["\nWe are almost there" <> _ = msg]} assert msg =~ "$ cd another" assert msg =~ "$ mix deps.get" refute_received {:mix_shell, :info, ["Then configure your database" <> _]} assert_received {:mix_shell, :info, ["Start your Phoenix app" <> _]} # Gettext assert_file("another/lib/another/gettext.ex", ~r"defmodule Another.Gettext") assert File.exists?("another/priv/gettext/errors.pot") assert File.exists?("another/priv/gettext/en/LC_MESSAGES/errors.po") end) end end end ================================================ FILE: installer/test/phx_new_web_test.exs ================================================ Code.require_file "mix_helper.exs", __DIR__ defmodule Mix.Tasks.Phx.New.WebTest do use ExUnit.Case import MixHelper import ExUnit.CaptureIO @app_name "phx_web" setup do # The shell asks to install deps. # We will politely say not. send self(), {:mix_shell_input, :yes?, false} :ok end test "new without args" do assert capture_io(fn -> Mix.Tasks.Phx.New.Web.run([]) end) =~ "Creates a new Phoenix web project within an umbrella project." end test "new with barebones umbrella" do in_tmp_umbrella_project "new with barebones umbrella", fn -> files = ~w[../config/dev.exs ../config/test.exs ../config/prod.exs ../config/runtime.exs] Enum.each(files, &File.rm/1) assert_file "../config/config.exs", &refute(&1 =~ ~S[import_config "#{config_env()}.exs"]) Mix.Tasks.Phx.New.Web.run([@app_name]) assert_file "../config/config.exs", &assert(&1 =~ ~S[import_config "#{config_env()}.exs"]) end end test "new outside umbrella", config do in_tmp config.test, fn -> assert_raise Mix.Error, ~r"The web task can only be run within an umbrella's apps directory", fn -> Mix.Tasks.Phx.New.Web.run ["007invalid"] end end end test "new with defaults" do in_tmp_umbrella_project "new with defaults", fn -> Mix.Tasks.Phx.New.Web.run([@app_name]) assert_file "../config/config.exs", fn file -> assert file =~ "generators: [context_app: false]" end assert_file "#{@app_name}/mix.exs", fn file -> assert file =~ "{:jason," end # Install dependencies? assert_received {:mix_shell, :yes?, ["\nFetch and install dependencies?"]} # Instructions assert_received {:mix_shell, :info, ["\nWe are almost there" <> _ = msg]} assert msg =~ "$ cd phx_web" assert msg =~ "$ mix deps.get" assert_received {:mix_shell, :info, ["Your web app requires a PubSub server to be running." <> _]} assert_received {:mix_shell, :info, ["Start your Phoenix app" <> _]} end end test "app_name is included in tailwind config" do in_tmp_umbrella_project "new with defaults", fn -> Mix.Tasks.Phx.New.Web.run(["testweb"]) assert_file "testweb/assets/vendor/heroicons.js", fn file -> assert file =~ "/deps/heroicons/optimized" end end end end ================================================ FILE: installer/test/test_helper.exs ================================================ ExUnit.start() ================================================ FILE: integration_test/README.md ================================================ ## Phoenix Integration Tests This project contains integration tests for phoenix's generated projects. ## Running tests To install dependencies, run: $ mix deps.get Then run the basic test suite (no dependencies on the database) with: $ mix test To run the test suite with tests that test a specific database, run: $ mix test --include database:postgresql $ mix test --include database:mysql $ mix test --include database:mssql $ mix test --include database:sqlite3 For convenience, there is also a `docker-compose.yml` file that allows for starting up all of the supported databases locally. $ docker-compose up This allows all tests to be run with the following command $ mix test --include database Or alternatively, with docker and docker compose installed, you can just run `./docker.sh`. ## How tests are written In order to have consistent, repeatable builds, all dependencies for all phoenix project variations are listed in `mix.exs` and locked via `mix.lock`. If a dependency version needs to be updated, it can be updated with `mix.exs` or using `mix deps.update `. It is also important to note that dependencies are initially compiled with `MIX_ENV=test` and then copied to `_build/dev_` to improve test speed. Therefore, dependencies should not be listed in `mix.exs` with an `only: ` option. ================================================ FILE: integration_test/config/config.exs ================================================ import Config config :phoenix, :json_library, Jason config :swoosh, api_client: false config :tailwind, :version, "4.1.12" config :phoenix_live_view, enable_expensive_runtime_checks: true ================================================ FILE: integration_test/docker-compose.yml ================================================ version: '3' services: postgres: image: postgres ports: - "5432:5432" environment: POSTGRES_PASSWORD: postgres mysql: image: mysql ports: - "3306:3306" environment: MYSQL_ALLOW_EMPTY_PASSWORD: "yes" mssql: image: mcr.microsoft.com/mssql/server:2019-latest environment: ACCEPT_EULA: Y SA_PASSWORD: some!Password ports: - "1433:1433" ================================================ FILE: integration_test/docker.sh ================================================ #!/usr/bin/env sh -e # adapt with versions from .github/versions/ci.yml if necessary; # you can also override these with environment variables ELIXIR="${ELIXIR:-1.19.5}" ERLANG="${ERLANG:-28.3.3}" SUFFIX="${SUFFIX:-alpine-3.20.9}" # Get the directory of the script SCRIPT_DIR=$(dirname "$(readlink -f "$0")") # Get the parent directory PARENT_DIR=$(dirname "$SCRIPT_DIR") # Check if docker-compose is available if command -v docker-compose &> /dev/null then COMPOSE_CMD="docker-compose" elif docker compose version &> /dev/null then COMPOSE_CMD="docker compose" else echo "Error: Neither docker-compose nor the docker compose plugin is available." exit 1 fi # Start databases $COMPOSE_CMD up -d # Run test script in container docker run --rm --network=integration_test_default \ -w $PARENT_DIR -v $PARENT_DIR:$PARENT_DIR \ -it hexpm/elixir:$ELIXIR-erlang-$ERLANG-$SUFFIX sh integration_test/test.sh $COMPOSE_CMD down ================================================ FILE: integration_test/mix.exs ================================================ for path <- :code.get_path(), Regex.match?(~r/phx_new-[\w\.\-]+\/ebin$/, List.to_string(path)) do Code.delete_path(path) end defmodule Phoenix.Integration.MixProject do use Mix.Project def project do [ app: :phoenix_integration, version: "0.1.0", elixir: "~> 1.15", elixirc_paths: elixirc_paths(Mix.env()), start_permanent: Mix.env() == :prod, deps: deps() ] end defp elixirc_paths(:test), do: ["lib", "test/support"] defp elixirc_paths(_), do: ["lib"] def application do [ extra_applications: [:logger, :inets] ] end # IMPORTANT: Dependencies are initially compiled with `MIX_ENV=test` and then # copied to `_build/dev` to save time. Any dependencies with `only: :dev` set # will not be copied. defp deps do [ {:phx_new, path: "../installer"}, {:phoenix, path: "..", override: true}, {:phoenix_ecto, "~> 4.5"}, {:esbuild, "~> 0.10", runtime: false}, {:ecto_sql, "~> 3.13"}, {:postgrex, ">= 0.0.0"}, {:myxql, ">= 0.0.0"}, {:tds, ">= 0.0.0"}, {:ecto_sqlite3, ">= 0.0.0"}, {:phoenix_html, "~> 4.1"}, {:phoenix_live_view, "~> 1.1.0"}, {:dns_cluster, "~> 0.2.0"}, {:lazy_html, ">= 0.1.0"}, {:phoenix_live_reload, "~> 1.2"}, {:phoenix_live_dashboard, "~> 0.8.3"}, {:telemetry_metrics, "~> 1.0"}, {:telemetry_poller, "~> 1.0"}, {:gettext, "~> 1.0"}, {:jason, "~> 1.2"}, {:swoosh, "~> 1.16"}, {:bandit, "~> 1.0"}, {:bcrypt_elixir, "~> 3.0"}, {:argon2_elixir, "~> 4.0"}, {:pbkdf2_elixir, "~> 2.0"}, {:tailwind, "~> 0.3"}, {:heroicons, github: "tailwindlabs/heroicons", tag: "v2.2.0", sparse: "optimized", app: false, compile: false, depth: 1}, {:req, "~> 0.5"} ] end end ================================================ FILE: integration_test/test/code_generation/app_with_defaults_test.exs ================================================ defmodule Phoenix.Integration.CodeGeneration.AppWithDefaultsTest do use Phoenix.Integration.CodeGeneratorCase, async: true describe "new with defaults" do test "has no compilation or formatter warnings" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog") assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_app") drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.html" do test "has no compilation or formatter warnings" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog") mix_run!(~w(phx.gen.html Blog Post posts title:unique body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] resources "/posts", PostController end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog") mix_run!(~w(phx.gen.html Blog Post posts title:unique body:string status:enum:unpublished:published:deleted order:integer:unique), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] resources "/posts", PostController end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.json" do test "has no compilation or formatter warnings" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog") mix_run!(~w(phx.gen.json Blog Post posts title:unique body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", PhxBlogWeb do pipe_through [:api] resources "/posts", PostController, except: [:new, :edit] end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog") mix_run!(~w(phx.gen.json Blog Post posts title:unique body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", PhxBlogWeb do pipe_through [:api] resources "/posts", PostController, except: [:new, :edit] end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.live" do test "has no compilation or formatter warnings" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--live"]) mix_run!(~w(phx.gen.live Blog Post posts title:unique body:string p:boolean s:enum:a:b:c), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--live"]) mix_run!(~w(phx.gen.live Blog Post posts title body:string public:boolean status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.auth + bcrypt" do test "has no compilation or formatter warnings (--live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog") mix_run!(~w(phx.gen.auth Accounts User users --live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end test "has no compilation or formatter warnings (--no-live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog") mix_run!(~w(phx.gen.auth Accounts User users --no-live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite (--live)" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_app") mix_run!(~w(phx.gen.auth Accounts User users --live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end @tag database: :postgresql test "has a passing test suite (--no-live)" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_app") mix_run!(~w(phx.gen.auth Accounts User users --no-live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end end ================================================ FILE: integration_test/test/code_generation/app_with_mssql_adapter_test.exs ================================================ defmodule Phoenix.Integration.CodeGeneration.AppWithMSSQLAdapterTest do use Phoenix.Integration.CodeGeneratorCase, async: true describe "phx.gen.html" do @tag database: :mssql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_mssql_app", ["--database", "mssql"]) mix_run!(~w(phx.gen.html Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_mssql_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", DefaultMssqlAppWeb do pipe_through [:browser] resources "/posts", PostController end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.json" do @tag database: :mssql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_mssql_app", ["--database", "mssql"]) mix_run!(~w(phx.gen.json Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_mssql_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", DefaultMssqlAppWeb do pipe_through [:api] resources "/posts", PostController, except: [:new, :edit] end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.live" do @tag database: :mssql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_mssql_app", ["--database", "mssql", "--live"]) mix_run!(~w(phx.gen.live Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_mssql_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", DefaultMssqlAppWeb do pipe_through [:browser] live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.auth + pbkdf2 + existing context" do test "has no compilation or formatter warnings (--live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "mssql", "--live"]) mix_run!(~w(phx.gen.html Accounts Group groups name), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] resources "/groups", GroupController end """) end) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib pbkdf2 --merge-with-existing-context --live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end test "has no compilation or formatter warnings (--no-live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "mssql", "--live"]) mix_run!(~w(phx.gen.html Accounts Group groups name), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] resources "/groups", GroupController end """) end) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib pbkdf2 --merge-with-existing-context --no-live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :mssql test "has a passing test suite" do with_installer_tmp("app_with_defaults (--live)", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "mssql", "--live"]) mix_run!(~w(phx.gen.html Accounts Group groups name), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] resources "/groups", GroupController end """) end) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib pbkdf2 --merge-with-existing-context --live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end @tag database: :mssql test "has a passing test suite (--no-live)" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "mssql", "--live"]) mix_run!(~w(phx.gen.html Accounts Group groups name), app_root_path) modify_file(Path.join(app_root_path, "lib/phx_blog_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", PhxBlogWeb do pipe_through [:browser] resources "/groups", GroupController end """) end) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib pbkdf2 --merge-with-existing-context --no-live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end end ================================================ FILE: integration_test/test/code_generation/app_with_mysql_adapter_test.exs ================================================ defmodule Phoenix.Integration.CodeGeneration.AppWithMySqlAdapterTest do use Phoenix.Integration.CodeGeneratorCase, async: true describe "phx.gen.html" do @tag database: :mysql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_mysql_app", ["--database", "mysql"]) mix_run!(~w(phx.gen.html Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_mysql_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", DefaultMysqlAppWeb do pipe_through [:browser] resources "/posts", PostController end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.json" do @tag database: :mysql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_mysql_app", ["--database", "mysql"]) mix_run!(~w(phx.gen.json Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_mysql_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", DefaultMysqlAppWeb do pipe_through [:api] resources "/posts", PostController, except: [:new, :edit] end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.live" do @tag database: :mysql test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_mysql_app", ["--database", "mysql", "--live"]) mix_run!(~w(phx.gen.live Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_mysql_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", DefaultMysqlAppWeb do pipe_through [:browser] live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.auth + argon2" do test "has no compilation or formatter warnings (--live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "mysql", "--binary-id"]) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib argon2 --live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end test "has no compilation or formatter warnings (--no-live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "mysql", "--binary-id"]) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib argon2 --no-live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :mysql test "has a passing test suite (--live)" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_app", ["--database", "mysql", "--binary-id"]) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib argon2 --live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end @tag database: :mysql test "has a passing test suite (--no-live)" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_app", ["--database", "mysql", "--binary-id"]) mix_run!(~w(phx.gen.auth Accounts User users --hashing-lib argon2 --no-live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end end ================================================ FILE: integration_test/test/code_generation/app_with_no_options_test.exs ================================================ defmodule Phoenix.Integration.CodeGeneration.AppWithNoOptionsTest do use Phoenix.Integration.CodeGeneratorCase, async: true @epoch {{1970, 1, 1}, {0, 0, 0}} test "newly generated app has no warnings or errors" do with_installer_tmp("app_with_no_options", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", [ "--no-html", "--no-assets", "--no-ecto", "--no-gettext", "--no-mailer", "--no-dashboard" ]) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) assert_tests_pass(app_root_path) end) end test "development workflow works as expected" do with_installer_tmp("development_workflow", [autoremove?: false], fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", [ "--no-assets", "--no-ecto", "--no-gettext", "--no-mailer", "--no-dashboard" ]) assert_no_compilation_warnings(app_root_path) File.touch!(Path.join(app_root_path, "lib/phx_blog_web/components/core_components.ex"), @epoch) File.touch!(Path.join(app_root_path, "lib/phx_blog_web/controllers/page_html.ex"), @epoch) spawn_link(fn -> run_phx_server(app_root_path) end) :inets.start() {:ok, response} = request_with_retries("http://localhost:4000", 20) assert response.status_code == 200 assert response.body =~ "PhxBlog" assert File.stat!(Path.join(app_root_path, "lib/phx_blog_web/components/core_components.ex")) > @epoch assert File.stat!(Path.join(app_root_path, "lib/phx_blog_web/controllers/page_html.ex")) > @epoch assert_tests_pass(app_root_path) end) end defp run_phx_server(app_root_path) do {_output, 0} = System.cmd( "elixir", [ "--no-halt", "-e", "spawn fn -> IO.gets([]) && System.halt(0) end", "-S", "mix", "phx.server" ], cd: app_root_path ) end defp request_with_retries(url, retries) defp request_with_retries(_url, 0), do: {:error, :out_of_retries} defp request_with_retries(url, retries) do case url |> to_charlist() |> :httpc.request() do {:ok, httpc_response} -> {{_, status_code, _}, raw_headers, body} = httpc_response {:ok, %{ status_code: status_code, headers: for({k, v} <- raw_headers, do: {to_string(k), to_string(v)}), body: to_string(body) }} {:error, {:failed_connect, _}} -> Process.sleep(5_000) request_with_retries(url, retries - 1) {:error, reason} -> {:error, reason} end end end ================================================ FILE: integration_test/test/code_generation/app_with_scopes_test.exs ================================================ defmodule Phoenix.Integration.CodeGeneration.AppWithScopesTest do use Phoenix.Integration.CodeGeneratorCase, async: true describe "phx.gen.auth" do test "generates scope for phx.gen.live" do with_installer_tmp("scopes", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "scopes") mix_run!(~w(phx.gen.auth Accounts User users --live), app_root_path) # we need to wait, otherwise we'd generate two migrations with the same version... Process.sleep(1500) mix_run!(~w(phx.gen.live Blog Post posts title:string), app_root_path) modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> String.replace( file, """ live "/users/settings/confirm-email/:token", UserLive.Settings, :confirm_email """, """ live "/users/settings/confirm-email/:token", UserLive.Settings, :confirm_email live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit """ ) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end test "generates scope for phx.gen.html" do with_installer_tmp("scopes", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "scopes") mix_run!(~w(phx.gen.auth Accounts User users --no-live), app_root_path) # we need to wait, otherwise we'd generate two migrations with the same version... Process.sleep(1500) mix_run!(~w(phx.gen.html Blog Post posts title:string), app_root_path) modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> String.replace( file, """ get "/users/settings/confirm-email/:token", UserSettingsController, :confirm_email """, """ get "/users/settings/confirm-email/:token", UserSettingsController, :confirm_email resources "/posts", PostController """ ) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end test "generates scope for phx.gen.json" do with_installer_tmp("scopes", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "scopes") mix_run!(~w(phx.gen.auth Accounts User users --no-live), app_root_path) # we need to wait, otherwise we'd generate two migrations with the same version... Process.sleep(1500) mix_run!(~w(phx.gen.json Blog Post posts title:string), app_root_path) modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", ScopesWeb do pipe_through [ :api, :fetch_session, :fetch_current_scope_for_user, :require_authenticated_user ] resources "/posts", PostController, except: [:new, :edit] end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "custom scope" do test "route_prefix and route_access_path with all generators" do with_installer_tmp("scopes", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "scopes", ["--live"]) # First generate authentication system mix_run!(~w(phx.gen.auth Accounts User users --live), app_root_path) # sleep to have fresh migration name Process.sleep(1500) mix_run!(~w(ecto.gen.migration AddOrganizationAndOrgUser), app_root_path) assert [migration] = Path.wildcard( Path.join( app_root_path, "priv/repo/migrations/*_add_organization_and_org_user.exs" ) ) File.write!(migration, """ defmodule Scopes.Repo.Migrations.AddOrganizationAndOrgUser do use Ecto.Migration def change do create table(:organizations) do add :name, :string add :slug, :string add :user_id, references(:users, type: :id, on_delete: :delete_all) timestamps(type: :utc_datetime) end create unique_index(:organizations, [:slug]) create table(:organizations_users) do add :role, :string add :organization_id, references(:organizations, on_delete: :nothing) add :user_id, references(:users, on_delete: :delete_all) timestamps(type: :utc_datetime) end create index(:organizations_users, [:organization_id]) create index(:organizations_users, [:user_id]) end end """) File.write!(Path.join(app_root_path, "lib/scopes/accounts/organization.ex"), """ defmodule Scopes.Accounts.Organization do use Ecto.Schema import Ecto.Changeset alias Scopes.Accounts.User @derive {Phoenix.Param, key: :slug} schema "organizations" do field :name, :string field :slug, :string many_to_many :users, User, join_through: "organizations_users" timestamps(type: :utc_datetime) end @doc false def changeset(organization, attrs) do organization |> cast(attrs, [:name, :slug]) |> validate_required([:name, :slug]) |> unique_constraint(:slug) end end """) File.write!(Path.join(app_root_path, "lib/scopes/accounts/organization_user.ex"), """ defmodule Scopes.Accounts.OrganizationUser do use Ecto.Schema import Ecto.Changeset schema "organizations_users" do field :role, :string belongs_to :organization, Scopes.Accounts.Organization belongs_to :user, Scopes.Accounts.User timestamps(type: :utc_datetime) end @doc false def changeset(organization_user, attrs, user_scope \\\\ nil) do organization_user |> cast(attrs, [:role, :organization_id, :user_id]) |> validate_required([:role, :organization_id]) |> maybe_put_user_id(user_scope) end defp maybe_put_user_id(changeset, %{user: %{id: user_id}}) do put_change(changeset, :user_id, user_id) end defp maybe_put_user_id(changeset, _), do: changeset end """) # Update context modify_file(Path.join(app_root_path, "lib/scopes/accounts.ex"), fn file -> inject_before_final_end(file, ~S''' ## Organization operations alias Scopes.Accounts.{Organization, OrganizationUser} @doc """ Returns the list of organizations the user has access to. """ def list_organizations(scope) do user_id = scope.user.id OrganizationUser |> where([ou], ou.user_id == ^user_id) |> join(:inner, [ou], o in Organization, on: o.id == ou.organization_id) |> select([_ou, o], o) |> Repo.all() end @doc """ Gets an organization by slug. """ def get_organization_by_slug!(scope, slug) when is_binary(slug) do # This function would typically check if the user has access to the organization # For this example, we'll just return the organization by slug Repo.one!( from o in Organization, join: ou in OrganizationUser, on: ou.organization_id == o.id, join: u in User, on: ou.user_id == u.id, where: u.id == ^scope.user.id, select: o ) end @doc """ Creates an organization. """ def create_organization(scope, attrs \\ %{}) do %Organization{} |> Organization.changeset(attrs) |> Repo.insert() |> case do {:ok, organization} -> # Create a membership for the user who created the organization %OrganizationUser{} |> OrganizationUser.changeset(%{ organization_id: organization.id, user_id: scope.user.id, role: "owner" }) |> Repo.insert() {:ok, organization} error -> error end end ''') end) # Update Scope struct to include organization modify_file(Path.join(app_root_path, "lib/scopes/accounts/scope.ex"), fn file -> String.replace(file, "defstruct user: nil", "defstruct user: nil, organization: nil") |> inject_before_final_end(""" def put_organization(%__MODULE__{} = scope, %Scopes.Accounts.Organization{} = organization) do %{scope | organization: organization} end """) end) # Update the fixtures to support organization_scope_fixture modify_file( Path.join(app_root_path, "test/support/fixtures/accounts_fixtures.ex"), fn file -> inject_before_final_end(file, """ def valid_organization_attributes(attrs \\\\ %{}) do Enum.into(attrs, %{ name: "org\#{System.unique_integer()}", slug: "org\#{System.unique_integer()}" }) end def organization_fixture(scope \\\\ user_scope_fixture()) do attrs = valid_organization_attributes() {:ok, organization} = Accounts.create_organization(scope, attrs) organization end def organization_scope_fixture(scope \\\\ user_scope_fixture()) do org = organization_fixture(scope) Scope.put_organization(scope, org) end """) end ) # Add the register_and_log_in_user_with_org helper to ConnCase modify_file(Path.join(app_root_path, "test/support/conn_case.ex"), fn file -> inject_before_final_end(file, """ def register_and_log_in_user_with_org(context) do %{conn: conn, user: user, scope: scope} = register_and_log_in_user(context) scope = Scopes.AccountsFixtures.organization_scope_fixture(scope) %{conn: conn, user: user, scope: scope} end """) end) # Modify the scopes config to include route_prefix and route_access_path for organization modify_file(Path.join(app_root_path, "config/config.exs"), fn file -> String.replace( file, """ config :scopes, :scopes, user: [ default: true, module: Scopes.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users, test_data_fixture: Scopes.AccountsFixtures, test_setup_helper: :register_and_log_in_user ] """, """ config :scopes, :scopes, user: [ default: true, module: Scopes.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users, test_data_fixture: Scopes.AccountsFixtures, test_setup_helper: :register_and_log_in_user ], organization: [ module: Scopes.Accounts.Scope, assign_key: :current_scope, access_path: [:organization, :id], route_prefix: "/orgs/:slug", schema_key: :organization_id, schema_type: :id, schema_table: :organizations, test_data_fixture: Scopes.AccountsFixtures, test_setup_helper: :register_and_log_in_user_with_org ] """ ) end) # Extend the user auth module to assign org to scope modify_file( Path.join(app_root_path, "lib/scopes_web/user_auth.ex"), fn file -> inject_before_final_end(file, """ def assign_org_to_scope(conn, _opts) do current_scope = conn.assigns.current_scope if slug = conn.params["slug"] do org = Scopes.Accounts.get_organization_by_slug!(current_scope, slug) assign(conn, :current_scope, Scopes.Accounts.Scope.put_organization(current_scope, org)) else conn end end """) end ) # Add the LiveView hook for organization assignment modify_file( Path.join(app_root_path, "lib/scopes_web/user_auth.ex"), fn file -> String.replace( file, """ def on_mount(:mount_current_scope, _params, session, socket) do {:cont, mount_current_scope(socket, session)} end """, """ def on_mount(:mount_current_scope, _params, session, socket) do {:cont, mount_current_scope(socket, session)} end def on_mount(:assign_org_to_scope, %{"slug" => slug}, _session, socket) do socket = case socket.assigns.current_scope do %{organization: nil} = scope -> org = Scopes.Accounts.get_organization_by_slug!(socket.assigns.current_scope, slug) Phoenix.Component.assign(socket, :current_scope, Scope.put_organization(scope, org)) _ -> socket end {:cont, socket} end def on_mount(:assign_org_to_scope, _params, _session, socket), do: {:cont, socket} """ ) end ) # Update the router to use the assign_org_to_scope plug modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> String.replace(file, "plug :fetch_current_scope_for_user", """ plug :fetch_current_scope_for_user plug :assign_org_to_scope """) end) # Generate resources with all three generators - use different contexts to avoid naming conflicts Process.sleep(1500) mix_run!( ~w(phx.gen.html Blog1 Article articles title:string --scope organization), app_root_path ) Process.sleep(1500) mix_run!( ~w(phx.gen.live Blog2 Post posts title:string --scope organization), app_root_path ) Process.sleep(1500) mix_run!( ~w(phx.gen.json Blog3 Comment comments content:string --scope organization), app_root_path ) # Update LiveView routes in router.ex modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> String.replace( file, "{ScopesWeb.UserAuth, :require_authenticated}", "{ScopesWeb.UserAuth, :require_authenticated}, {ScopesWeb.UserAuth, :assign_org_to_scope}" ) |> String.replace( "live \"/users/settings/confirm-email/:token\", UserLive.Settings, :confirm_email", """ live "/users/settings/confirm-email/:token", UserLive.Settings, :confirm_email live "/orgs/:slug/posts", PostLive.Index, :index live "/orgs/:slug/posts/new", PostLive.Form, :new live "/orgs/:slug/posts/:id", PostLive.Show, :show live "/orgs/:slug/posts/:id/edit", PostLive.Form, :edit """ ) end) # Add the HTML routes modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> String.replace( file, "post \"/users/update-password\", UserSessionController, :update_password", """ post "/users/update-password", UserSessionController, :update_password resources "/orgs/:slug/articles", ArticleController """ ) end) # Add the JSON API routes modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> router_code = """ # API routes scope "/api", ScopesWeb do pipe_through [:api, :fetch_session, :fetch_current_scope_for_user, :assign_org_to_scope, :require_authenticated_user] resources "/orgs/:slug/comments", CommentController, except: [:new, :edit] end """ inject_before_final_end(file, router_code) end) # Test HTML generator (Articles) assert_file( Path.join(app_root_path, "lib/scopes_web/controllers/article_html/index.html.heex"), fn file -> assert file =~ ~s|href={~p"/orgs/\#{@current_scope.organization}/articles/new"| assert file =~ ~s|navigate={~p"/orgs/\#{@current_scope.organization}/articles/\#{article}"| end ) assert_file( Path.join(app_root_path, "lib/scopes_web/controllers/article_controller.ex"), fn file -> assert file =~ ~s|redirect(to: ~p"/orgs/\#{conn.assigns.current_scope.organization}/articles/\#{article}"| end ) assert_file( Path.join(app_root_path, "test/scopes_web/controllers/article_controller_test.exs"), fn file -> assert file =~ ~s|~p"/orgs/\#{scope.organization}/articles"| end ) # Test LiveView generator (Posts) assert_file(Path.join(app_root_path, "lib/scopes_web/live/post_live/index.ex"), fn file -> assert file =~ ~s|navigate={~p"/orgs/\#{@current_scope.organization}/posts/new"| assert file =~ ~s|JS.navigate(~p"/orgs/\#{@current_scope.organization}/posts/\#{post}")| end) assert_file(Path.join(app_root_path, "lib/scopes_web/live/post_live/show.ex"), fn file -> assert file =~ ~s|navigate={~p"/orgs/\#{@current_scope.organization}/posts"| end) assert_file( Path.join(app_root_path, "test/scopes_web/live/post_live_test.exs"), fn file -> assert file =~ ~s|~p"/orgs/\#{scope.organization}/posts"| end ) # Test JSON generator (Comments) assert_file( Path.join(app_root_path, "lib/scopes_web/controllers/comment_controller.ex"), fn file -> assert file =~ ~s|~p"/api/orgs/\#{conn.assigns.current_scope.organization}/comments/\#{comment}"| end ) assert_file( Path.join(app_root_path, "test/scopes_web/controllers/comment_controller_test.exs"), fn file -> assert file =~ ~s|~p"/api/orgs/\#{scope.organization}/comments"| end ) # Final app validations assert_no_compilation_warnings(app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end test "phx.gen.json" do with_installer_tmp("scopes", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "scopes") modify_file(Path.join(app_root_path, "config/config.exs"), fn file -> String.replace(file, "import Config", """ import Config config :scopes, :scopes, user: [ default: false, module: Scopes.UserScope, assign_key: :user_scope, access_path: [:u, :id], schema_key: :user_id, schema_type: :integer, schema_migration_type: :bigint, schema_table: nil, test_data_fixture: Scopes.UserScopeFixtures, test_setup_helper: :assign_scope ]\ """) end) mix_run!(~w(phx.gen.json Blog Post posts title:string --scope user), app_root_path) File.write!(Path.join(app_root_path, "test/support/fixtures/user_scope_fixtures.ex"), """ defmodule Scopes.UserScopeFixtures do alias Scopes.UserScope def user_scope_fixture(id \\\\ System.unique_integer()) do %UserScope{u: %{id: id}} end end """) modify_file(Path.join(app_root_path, "test/support/conn_case.ex"), fn file -> inject_before_final_end(file, """ def assign_scope(%{conn: conn}) do id = System.unique_integer() scope = Scopes.UserScopeFixtures.user_scope_fixture(id) conn = conn |> Phoenix.ConnTest.init_test_session(%{}) |> Plug.Conn.put_session(:user_id, id) %{conn: conn, scope: scope} end """) end) File.write!(Path.join(app_root_path, "lib/scopes/user_scope.ex"), """ defmodule Scopes.UserScope do defstruct u: nil def new(attrs) do %Scopes.UserScope{u: attrs.u} end end """) modify_file(Path.join(app_root_path, "lib/scopes_web/router.ex"), fn file -> inject_before_final_end(file, """ defp assign_scope(conn, _opts) do conn = Plug.Conn.fetch_session(conn) id = Plug.Conn.get_session(conn, :user_id) || raise "no user id found in session" assign(conn, :user_scope, Scopes.UserScope.new(%{u: %{id: id}})) end scope "/api", ScopesWeb do pipe_through [:api, :assign_scope] resources "/posts", PostController, except: [:new, :edit] end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end end ================================================ FILE: integration_test/test/code_generation/app_with_sqlite3_adapter_test.exs ================================================ defmodule Phoenix.Integration.CodeGeneration.AppWithSQLite3AdapterTest do use Phoenix.Integration.CodeGeneratorCase, async: true describe "phx.gen.html" do @tag database: :sqlite3 test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_sqlite3_app", ["--database", "sqlite3"]) mix_run!(~w(phx.gen.html Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_sqlite3_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", DefaultSqlite3AppWeb do pipe_through [:browser] resources "/posts", PostController end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.json" do @tag database: :sqlite3 test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_sqlite3_app", ["--database", "sqlite3"]) mix_run!(~w(phx.gen.json Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_sqlite3_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", DefaultSqlite3AppWeb do pipe_through [:api] resources "/posts", PostController, except: [:new, :edit] end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.live" do @tag database: :sqlite3 test "has a passing test suite" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_sqlite3_app", ["--database", "sqlite3", "--live"]) mix_run!(~w(phx.gen.live Blog Post posts title body:string status:enum:unpublished:published:deleted), app_root_path) modify_file(Path.join(app_root_path, "lib/default_sqlite3_app_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", DefaultSqlite3AppWeb do pipe_through [:browser] live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.auth + bcrypt" do test "has no compilation or formatter warnings (--live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "sqlite3"]) mix_run!(~w(phx.gen.auth Accounts User users --live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end test "has no compilation or formatter warnings (--no-live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--database", "sqlite3"]) mix_run!(~w(phx.gen.auth Accounts User users --no-live), app_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :sqlite3 test "has a passing test suite (--live)" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_app", ["--database", "sqlite3"]) mix_run!(~w(phx.gen.auth Accounts User users --live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end test "has a passing test suite (--no-live)" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "default_app", ["--database", "sqlite3"]) mix_run!(~w(phx.gen.auth Accounts User users --no-live), app_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end end ================================================ FILE: integration_test/test/code_generation/umbrella_app_with_defaults_test.exs ================================================ defmodule Phoenix.Integration.CodeGeneration.UmbrellaAppWithDefaultsTest do use Phoenix.Integration.CodeGeneratorCase, async: true describe "new umbrella app" do test "has no compilation or formatter warnings" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "phx_blog", ["--umbrella"]) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "umbrella_with_defaults", ["--umbrella"]) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.html" do test "has no compilation or formatter warnings" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.html Blog Post posts title:unique body:string status:enum:unpublished:published:deleted), web_root_path) modify_file(Path.join(web_root_path, "lib/rainy_day_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", RainyDayWeb do pipe_through [:browser] resources "/posts", PostController end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.html Blog Post posts title body:string status:enum:unpublished:published:deleted), web_root_path) modify_file(Path.join(web_root_path, "lib/rainy_day_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", RainyDayWeb do pipe_through [:browser] resources "/posts", PostController end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.json" do test "has no compilation or formatter warnings" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.json Blog Post posts title:unique body:string status:enum:unpublished:published:deleted), web_root_path) modify_file(Path.join(web_root_path, "lib/rainy_day_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", RainyDayWeb do pipe_through [:api] resources "/posts", PostController, except: [:new, :edit] end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.json Blog Post posts title body:string status:enum:unpublished:published:deleted), web_root_path) modify_file(Path.join(web_root_path, "lib/rainy_day_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/api", RainyDayWeb do pipe_through [:api] resources "/posts", PostController, except: [:new, :edit] end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.live" do test "has no compilation or formatter warnings" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella", "--live"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.live Blog Post posts title:unique body:string status:enum:unpublished:published:deleted), web_root_path) modify_file(Path.join(web_root_path, "lib/rainy_day_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", RainyDayWeb do pipe_through [:browser] live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """) end) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite" do with_installer_tmp("umbrella_app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella", "--live"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.live Blog Post posts title body:string status:enum:unpublished:published:deleted), web_root_path) modify_file(Path.join(web_root_path, "lib/rainy_day_web/router.ex"), fn file -> inject_before_final_end(file, """ scope "/", RainyDayWeb do pipe_through [:browser] live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """) end) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end describe "phx.gen.auth + bcrypt" do test "has no compilation or formatter warnings (--live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.auth Accounts User users --live), web_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end test "has no compilation or formatter warnings (--no-live)" do with_installer_tmp("new with defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.auth Accounts User users --no-live), web_root_path) assert_no_compilation_warnings(app_root_path) assert_passes_formatter_check(app_root_path) end) end @tag database: :postgresql test "has a passing test suite --live" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.auth Accounts User users --live), web_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end @tag database: :postgresql test "has a passing test suite --no-live" do with_installer_tmp("app_with_defaults", fn tmp_dir -> {app_root_path, _} = generate_phoenix_app(tmp_dir, "rainy_day", ["--umbrella"]) web_root_path = Path.join(app_root_path, "apps/rainy_day_web") mix_run!(~w(phx.gen.auth Accounts User users --no-live), web_root_path) drop_test_database(app_root_path) assert_tests_pass(app_root_path) end) end end end ================================================ FILE: integration_test/test/support/code_generator_case.ex ================================================ defmodule Phoenix.Integration.CodeGeneratorCase do use ExUnit.CaseTemplate using do quote do import unquote(__MODULE__) end end def generate_phoenix_app(tmp_dir, app_name, opts \\ []) when is_binary(app_name) and is_list(opts) do app_path = Path.expand(app_name, tmp_dir) integration_test_root_path = Path.expand("../../", __DIR__) app_root_path = get_app_root_path(tmp_dir, app_name, opts) output = mix_run!(["phx.new", app_path, "--dev", "--no-install"] ++ opts, integration_test_root_path) for path <- ~w(mix.lock deps _build) do File.cp_r!( Path.join(integration_test_root_path, path), Path.join(app_root_path, path) ) end {app_root_path, output} end def mix_run!(args, app_path, opts \\ []) when is_list(args) and is_binary(app_path) and is_list(opts) do case mix_run(args, app_path, opts) do {output, 0} -> output {output, exit_code} -> raise """ mix command failed with exit code: #{inspect(exit_code)} mix #{Enum.join(args, " ")} #{output} Options cd: #{Path.expand(app_path)} env: #{opts |> Keyword.get(:env, []) |> inspect()} """ end end def mix_run(args, app_path, opts \\ []) when is_list(args) and is_binary(app_path) and is_list(opts) do System.cmd("mix", args, [stderr_to_stdout: true, cd: Path.expand(app_path)] ++ opts) end def assert_dir(path) do assert File.dir?(path), "Expected #{path} to be a directory, but is not" end def assert_file(file) do assert File.regular?(file), "Expected #{file} to exist, but does not" end def refute_file(file) do refute File.regular?(file), "Expected #{file} to not exist, but it does" end def assert_file(file, match) do cond do is_list(match) -> assert_file(file, &Enum.each(match, fn m -> assert &1 =~ m end)) is_binary(match) or is_struct(match, Regex) -> assert_file(file, &assert(&1 =~ match)) is_function(match, 1) -> assert_file(file) match.(File.read!(file)) true -> raise inspect({file, match}) end end def assert_tests_pass(app_path) do mix_run!(~w(test), app_path) end def assert_passes_formatter_check(app_path) do mix_run!(~w(format --check-formatted), app_path) end def assert_no_compilation_warnings(app_path) do mix_run!(["do", "clean,", "compile", "--warnings-as-errors"], app_path) end def drop_test_database(app_path) when is_binary(app_path) do mix_run!(["ecto.drop"], app_path, env: [{"MIX_ENV", "test"}]) end def with_installer_tmp(name, opts \\ [], function) when is_list(opts) and is_function(function, 1) do autoremove? = Keyword.get(opts, :autoremove?, true) path = Path.join([installer_tmp_path(), random_string(10), to_string(name)]) try do File.rm_rf!(path) File.mkdir_p!(path) function.(path) after if autoremove?, do: File.rm_rf!(path) end end defp installer_tmp_path do Path.expand("../../../installer/tmp", __DIR__) end def inject_before_final_end(code, code_to_inject) when is_binary(code) and is_binary(code_to_inject) do code |> String.trim_trailing() |> String.trim_trailing("end") |> Kernel.<>(code_to_inject) |> Kernel.<>("end\n") end def modify_file(path, function) when is_binary(path) and is_function(function, 1) do path |> File.read!() |> function.() |> write_file!(path) end defp write_file!(content, path) do File.write!(path, content) end defp get_app_root_path(tmp_dir, app_name, opts) do app_root_dir = if "--umbrella" in opts do app_name <> "_umbrella" else app_name end Path.expand(app_root_dir, tmp_dir) end defp random_string(len) do len |> :crypto.strong_rand_bytes() |> Base.url_encode64() |> binary_part(0, len) end end ================================================ FILE: integration_test/test/test_helper.exs ================================================ # Copy _build/test to _build/dev so it only has to be compiled once File.rm_rf!(Path.expand("../_build/dev", __DIR__)) File.cp_r!( Path.expand("../_build/test", __DIR__), Path.expand("../_build/dev", __DIR__) ) ExUnit.configure(timeout: 180_000, exclude: [:database]) ExUnit.start() ================================================ FILE: integration_test/test.sh ================================================ #!/bin/sh -e mix local.rebar --force mix local.hex --force # Install Dependencies apk add --no-progress --update git socat make gcc libc-dev cmake g++ # Set up local proxies socat TCP-LISTEN:5432,fork TCP-CONNECT:postgres:5432& socat TCP-LISTEN:3306,fork TCP-CONNECT:mysql:3306& socat TCP-LISTEN:1433,fork TCP-CONNECT:mssql:1433& # Run installer tests echo "Running installer tests" cd installer mix deps.get mix test echo "Running integration tests" cd ../integration_test mix deps.get mix test --include database ================================================ FILE: jest.config.js ================================================ /* * For a detailed explanation regarding each configuration property, visit: * https://jestjs.io/docs/configuration */ module.exports = { // Automatically clear mock calls and instances between every test clearMocks: true, // Indicates which provider should be used to instrument code for coverage coverageProvider: "v8", // The paths to modules that run some code to configure or set up the testing environment before each test setupFiles: [ // "/setupTests.js" ], // The test environment that will be used for testing testEnvironment: "jest-environment-jsdom", testEnvironmentOptions: { url: "https://example.com" }, // The regexp pattern or array of patterns that Jest uses to detect test files testRegex: "/assets/test/.*_test\\.js$", } ================================================ FILE: lib/mix/phoenix/context.ex ================================================ defmodule Mix.Phoenix.Context do @moduledoc false alias Mix.Phoenix.{Context, Schema} defstruct name: nil, module: nil, schema: nil, alias: nil, base_module: nil, web_module: nil, basename: nil, file: nil, test_file: nil, test_fixtures_file: nil, dir: nil, generate?: true, context_app: nil, opts: [], scope: nil def valid?(context) do context =~ ~r/^[A-Z]\w*(\.[A-Z]\w*)*$/ end def new(context_name, opts) do new(context_name, %Schema{}, opts) end def new(context_name, %Schema{} = schema, opts) do ctx_app = opts[:context_app] || Mix.Phoenix.context_app() base = Module.concat([Mix.Phoenix.context_base(ctx_app)]) module = Module.concat(base, context_name) alias = Module.concat([module |> Module.split() |> List.last()]) basedir = Phoenix.Naming.underscore(context_name) basename = Path.basename(basedir) dir = Mix.Phoenix.context_lib_path(ctx_app, basedir) file = dir <> ".ex" test_dir = Mix.Phoenix.context_test_path(ctx_app, basedir) test_file = test_dir <> "_test.exs" test_fixtures_dir = Mix.Phoenix.context_app_path(ctx_app, "test/support/fixtures") test_fixtures_file = Path.join([test_fixtures_dir, basedir <> "_fixtures.ex"]) generate? = Keyword.get(opts, :context, true) %Context{ name: context_name, module: module, schema: schema, alias: alias, base_module: base, web_module: web_module(), basename: basename, file: file, test_file: test_file, test_fixtures_file: test_fixtures_file, dir: dir, generate?: generate?, context_app: ctx_app, opts: opts, scope: schema.scope } end def pre_existing?(%Context{file: file}), do: File.exists?(file) def pre_existing_tests?(%Context{test_file: file}), do: File.exists?(file) def pre_existing_test_fixtures?(%Context{test_fixtures_file: file}), do: File.exists?(file) def function_count(%Context{file: file}) do {_ast, count} = file |> File.read!() |> Code.string_to_quoted!() |> Macro.postwalk(0, fn {:def, _, _} = node, count -> {node, count + 1} {:defdelegate, _, _} = node, count -> {node, count + 1} node, count -> {node, count} end) count end def file_count(%Context{dir: dir}) do dir |> Path.join("**/*.ex") |> Path.wildcard() |> Enum.count() end defp web_module do base = Mix.Phoenix.base() cond do Mix.Phoenix.context_app() != Mix.Phoenix.otp_app() -> Module.concat([base]) String.ends_with?(base, "Web") -> Module.concat([base]) true -> Module.concat(["#{base}Web"]) end end end ================================================ FILE: lib/mix/phoenix/schema.ex ================================================ defmodule Mix.Phoenix.Schema do @moduledoc false alias Mix.Phoenix.Schema defstruct module: nil, repo: nil, repo_alias: nil, table: nil, collection: nil, embedded?: false, generate?: true, opts: [], alias: nil, file: nil, attrs: [], string_attr: nil, plural: nil, singular: nil, uniques: [], redacts: [], assocs: [], types: [], indexes: [], defaults: [], human_singular: nil, human_plural: nil, binary_id: false, migration_defaults: nil, migration?: false, params: %{}, optionals: [], sample_id: nil, web_path: nil, web_namespace: nil, context_app: nil, route_helper: nil, route_prefix: nil, api_route_prefix: nil, migration_module: nil, fixture_unique_functions: [], fixture_params: [], prefix: nil, timestamp_type: :naive_datetime, scope: nil @valid_types [ :integer, :float, :decimal, :boolean, :map, :string, :array, :references, :text, :date, :time, :time_usec, :naive_datetime, :naive_datetime_usec, :utc_datetime, :utc_datetime_usec, :uuid, :binary, :enum ] def valid_types, do: @valid_types def valid?(schema) do schema =~ ~r/^[A-Z]\w*(\.[A-Z]\w*)*$/ end def new(schema_name, schema_plural, cli_attrs, opts) do ctx_app = opts[:context_app] || Mix.Phoenix.context_app() otp_app = Mix.Phoenix.otp_app() opts = Keyword.merge(Application.get_env(otp_app, :generators, []), opts) base = Mix.Phoenix.context_base(ctx_app) basename = Phoenix.Naming.underscore(schema_name) module = Module.concat([base, schema_name]) repo = opts[:repo] || Module.concat([base, "Repo"]) repo_alias = if String.ends_with?(Atom.to_string(repo), ".Repo"), do: "", else: ", as: Repo" file = Mix.Phoenix.context_lib_path(ctx_app, basename <> ".ex") table = opts[:table] || schema_plural scope = Mix.Phoenix.Scope.scope_from_opts(ctx_app, opts[:scope], opts[:no_scope]) {cli_attrs, uniques, redacts} = extract_attr_flags(cli_attrs) {assocs, attrs} = partition_attrs_and_assocs(module, attrs(cli_attrs), scope) types = types(attrs) web_namespace = opts[:web] && Phoenix.Naming.camelize(opts[:web]) web_path = web_namespace && Phoenix.Naming.underscore(web_namespace) api_prefix = Application.get_env(otp_app, :generators)[:api_prefix] || "/api" embedded? = Keyword.get(opts, :embedded, false) generate? = Keyword.get(opts, :schema, true) singular = module |> Module.split() |> List.last() |> Phoenix.Naming.underscore() collection = if schema_plural == singular, do: singular <> "_collection", else: schema_plural string_attr = string_attr(types) create_params = params(attrs, :create) optionals = for {key, :map} <- types, do: key, into: [] default_params_key = case Enum.at(create_params, 0) do {key, _} -> key nil -> :some_field end fixture_unique_functions = fixture_unique_functions(singular, uniques, attrs) %Schema{ opts: opts, migration?: Keyword.get(opts, :migration, true), module: module, repo: repo, repo_alias: repo_alias, table: table, embedded?: embedded?, alias: module |> Module.split() |> List.last() |> Module.concat(nil), file: file, attrs: attrs, plural: schema_plural, singular: singular, collection: collection, optionals: optionals, assocs: assocs, types: types, defaults: schema_defaults(attrs), uniques: uniques, redacts: redacts, indexes: indexes(table, assocs, uniques), human_singular: Phoenix.Naming.humanize(singular), human_plural: Phoenix.Naming.humanize(schema_plural), binary_id: opts[:binary_id], timestamp_type: opts[:timestamp_type] || :naive_datetime, migration_defaults: migration_defaults(attrs), string_attr: string_attr, params: %{ create: create_params, update: params(attrs, :update), default_key: string_attr || default_params_key }, web_namespace: web_namespace, web_path: web_path, route_helper: route_helper(web_path, singular), route_prefix: route_prefix(web_path, schema_plural), api_route_prefix: api_prefix, sample_id: sample_id(opts), context_app: ctx_app, generate?: generate?, migration_module: migration_module(), fixture_unique_functions: Enum.sort(fixture_unique_functions), fixture_params: fixture_params(attrs, fixture_unique_functions), prefix: opts[:prefix], scope: scope } end @doc """ Returns the string value of the default schema param. """ def default_param(%Schema{} = schema, action) do schema.params |> Map.fetch!(action) |> Map.fetch!(schema.params.default_key) |> to_string() end def extract_attr_flags(cli_attrs) do {attrs, uniques, redacts} = Enum.reduce(cli_attrs, {[], [], []}, fn attr, {attrs, uniques, redacts} -> [attr_name | rest] = String.split(attr, ":") attr_name = String.to_atom(attr_name) split_flags(Enum.reverse(rest), attr_name, attrs, uniques, redacts) end) {Enum.reverse(attrs), uniques, redacts} end defp split_flags(["unique" | rest], name, attrs, uniques, redacts), do: split_flags(rest, name, attrs, [name | uniques], redacts) defp split_flags(["redact" | rest], name, attrs, uniques, redacts), do: split_flags(rest, name, attrs, uniques, [name | redacts]) defp split_flags(rest, name, attrs, uniques, redacts), do: {[Enum.join([name | Enum.reverse(rest)], ":") | attrs], uniques, redacts} @doc """ Parses the attrs as received by generators. """ def attrs(attrs) do Enum.map(attrs, fn attr -> attr |> String.split(":", parts: 3) |> list_to_attr() |> validate_attr!() end) end @doc """ Generates some sample params based on the parsed attributes. """ def params(attrs, action \\ :create) when action in [:create, :update] do Map.new(attrs, fn {k, t} -> {k, type_to_default(k, t, action)} end) end @doc """ Converts the given value to map format when it's a date, time, datetime or naive_datetime. Since `form.html.heex` generated by the live generator uses selects for dates and/or times, fixtures must use map format for those fields in order to submit the live form. """ def live_form_value(%Date{} = date), do: Calendar.strftime(date, "%Y-%m-%d") def live_form_value(%Time{} = time), do: Calendar.strftime(time, "%H:%M") def live_form_value(%NaiveDateTime{} = naive) do NaiveDateTime.to_iso8601(naive) end def live_form_value(%DateTime{} = naive) do DateTime.to_iso8601(naive) end def live_form_value(value), do: value @doc """ Builds an invalid value for `@invalid_attrs` which is nil by default. * In case the value is a list, this will return an empty array. * In case the value is date, datetime, naive_datetime or time, this will return an invalid date. * In case it is a boolean, we keep it as false """ def invalid_form_value(value) when is_list(value), do: [] def invalid_form_value(%{day: _day, month: _month, year: _year} = _date), do: "2022-00" def invalid_form_value(%{hour: _hour, minute: _minute}), do: %{hour: 14, minute: 00} def invalid_form_value(true), do: false def invalid_form_value(_value), do: nil @doc """ Generates an invalid error message according to the params present in the schema. """ def failed_render_change_message(_schema) do "can't be blank" end def type_for_migration({:enum, _}), do: :string def type_for_migration(other), do: other def format_fields_for_schema(schema) do Enum.map_join(schema.types, "\n", fn {k, v} -> " field #{inspect(k)}, #{type_and_opts_for_schema(v)}#{schema.defaults[k]}#{maybe_redact_field(k in schema.redacts)}" end) end @doc """ Returns the required fields in the schema. Anything not in the `optionals` list is considered required. """ def required_fields(schema) do Enum.reject(schema.attrs, fn {key, _} -> key in schema.optionals end) end def type_and_opts_for_schema({:enum, opts}), do: ~s|Ecto.Enum, values: #{inspect(Keyword.get(opts, :values))}| def type_and_opts_for_schema(other), do: inspect(other) def maybe_redact_field(true), do: ", redact: true" def maybe_redact_field(false), do: "" @doc """ Returns the string value for use in EEx templates. """ def value(schema, field, value) do schema.types |> Keyword.fetch!(field) |> inspect_value(value) end defp inspect_value(:decimal, value), do: "Decimal.new(\"#{value}\")" defp inspect_value(_type, value), do: inspect(value) defp list_to_attr([key]), do: {String.to_atom(key), :string} defp list_to_attr([key, value]), do: {String.to_atom(key), String.to_atom(value)} defp list_to_attr([key, comp, value]) do {String.to_atom(key), {String.to_atom(comp), String.to_atom(value)}} end @one_day_in_seconds 24 * 3600 defp type_to_default(key, t, :create) do case t do {:array, type} -> build_array_values(type, :create) {:enum, values} -> build_enum_values(values, :create) :integer -> 42 :float -> 120.5 :decimal -> "120.5" :boolean -> true :map -> %{} :text -> "some #{key}" :date -> Date.add(Date.utc_today(), -1) :time -> ~T[14:00:00] :time_usec -> ~T[14:00:00.000000] :uuid -> "7488a646-e31f-11e4-aace-600308960662" :utc_datetime -> DateTime.add( build_utc_datetime(), -@one_day_in_seconds, :second, Calendar.UTCOnlyTimeZoneDatabase ) :utc_datetime_usec -> DateTime.add( build_utc_datetime_usec(), -@one_day_in_seconds, :second, Calendar.UTCOnlyTimeZoneDatabase ) :naive_datetime -> NaiveDateTime.add(build_utc_naive_datetime(), -@one_day_in_seconds) :naive_datetime_usec -> NaiveDateTime.add(build_utc_naive_datetime_usec(), -@one_day_in_seconds) _ -> "some #{key}" end end defp type_to_default(key, t, :update) do case t do {:array, type} -> build_array_values(type, :update) {:enum, values} -> build_enum_values(values, :update) :integer -> 43 :float -> 456.7 :decimal -> "456.7" :boolean -> false :map -> %{} :text -> "some updated #{key}" :date -> Date.utc_today() :time -> ~T[15:01:01] :time_usec -> ~T[15:01:01.000000] :uuid -> "7488a646-e31f-11e4-aace-600308960668" :utc_datetime -> build_utc_datetime() :utc_datetime_usec -> build_utc_datetime_usec() :naive_datetime -> build_utc_naive_datetime() :naive_datetime_usec -> build_utc_naive_datetime_usec() _ -> "some updated #{key}" end end defp build_array_values(:string, :create), do: Enum.map([1, 2], &"option#{&1}") defp build_array_values(:integer, :create), do: [1, 2] defp build_array_values(:string, :update), do: ["option1"] defp build_array_values(:integer, :update), do: [1] defp build_array_values(_, _), do: [] defp build_enum_values(values, action) do case {action, translate_enum_vals(values)} do {:create, vals} -> hd(vals) {:update, [val | []]} -> val {:update, vals} -> vals |> tl() |> hd() end end defp build_utc_datetime_usec, do: %{DateTime.utc_now() | second: 0, microsecond: {0, 6}} defp build_utc_datetime, do: DateTime.truncate(build_utc_datetime_usec(), :second) defp build_utc_naive_datetime_usec, do: %{NaiveDateTime.utc_now() | second: 0, microsecond: {0, 6}} defp build_utc_naive_datetime, do: NaiveDateTime.truncate(build_utc_naive_datetime_usec(), :second) @enum_missing_value_error """ Enum type requires at least one value For example: mix phx.gen.schema Comment comments body:text status:enum:published:unpublished """ defp validate_attr!({name, :datetime}), do: {name, :naive_datetime} defp validate_attr!({name, :array}) do Mix.raise(""" Phoenix generators expect the type of the array to be given to #{name}:array. For example: mix phx.gen.schema Post posts settings:array:string """) end defp validate_attr!({_name, :enum}), do: Mix.raise(@enum_missing_value_error) defp validate_attr!({_name, type} = attr) when type in @valid_types, do: attr defp validate_attr!({_name, {type, _}} = attr) when type in @valid_types, do: attr defp validate_attr!({_, type}) do Mix.raise( "Unknown type `#{inspect(type)}` given to generator. " <> "The supported types are: #{@valid_types |> Enum.sort() |> Enum.join(", ")}" ) end defp partition_attrs_and_assocs(schema_module, attrs, scope) do {assocs, attrs} = Enum.split_with(attrs, fn {_, {:references, _}} -> true {key, :references} -> Mix.raise(""" Phoenix generators expect the table to be given to #{key}:references. For example: mix phx.gen.schema Comment comments body:text post_id:references:posts """) _ -> false end) assocs = Enum.map(assocs, fn {key_id, {:references, source}} -> validate_scope_and_reference_conflict!(scope, key_id) key = String.replace(Atom.to_string(key_id), "_id", "") base = schema_module |> Module.split() |> Enum.drop(-1) module = Module.concat(base ++ [Phoenix.Naming.camelize(key)]) {String.to_atom(key), key_id, inspect(module), source} end) {assocs, attrs} end defp validate_scope_and_reference_conflict!( %Mix.Phoenix.Scope{schema_key: reference_key}, reference_key ) do Mix.raise(""" Reference #{inspect(reference_key)} has the same name as the scope schema key, either skip the reference or pass it with the --no-scope flag. """) end defp validate_scope_and_reference_conflict!(_scope, _source), do: :ok defp schema_defaults(attrs) do Enum.into(attrs, %{}, fn {key, :boolean} -> {key, ", default: false"} {key, _} -> {key, ""} end) end defp string_attr(types) do Enum.find_value(types, fn {key, :string} -> key _ -> false end) end defp types(attrs) do Keyword.new(attrs, fn {key, {:enum, vals}} -> {key, {:enum, values: translate_enum_vals(vals)}} {key, {root, val}} -> {key, {root, schema_type(val)}} {key, val} -> {key, schema_type(val)} end) end def translate_enum_vals(vals) do vals |> Atom.to_string() |> String.split(":") |> Enum.map(&String.to_atom/1) end defp schema_type(:text), do: :string defp schema_type(:uuid), do: Ecto.UUID defp schema_type(val) do if Code.ensure_loaded?(Ecto.Type) and not Ecto.Type.primitive?(val) do Mix.raise("Unknown type `#{val}` given to generator") else val end end defp indexes(table, assocs, uniques) do uniques = Enum.map(uniques, fn key -> {key, true} end) assocs = Enum.map(assocs, fn {_, key, _, _} -> {key, false} end) (uniques ++ assocs) |> Enum.uniq_by(fn {key, _} -> key end) |> Enum.map(fn {key, false} -> "create index(:#{table}, [:#{key}])" {key, true} -> "create unique_index(:#{table}, [:#{key}])" end) end defp migration_defaults(attrs) do Enum.into(attrs, %{}, fn {key, :boolean} -> {key, ", default: false, null: false"} {key, _} -> {key, ""} end) end defp sample_id(opts) do if Keyword.get(opts, :binary_id, false) do Keyword.get(opts, :sample_binary_id, "11111111-1111-1111-1111-111111111111") else -1 end end defp route_helper(web_path, singular) do "#{web_path}_#{singular}" |> String.trim_leading("_") |> String.replace("/", "_") end defp route_prefix(web_path, plural) do path = Path.join(for str <- [web_path, plural], do: to_string(str)) "/" <> String.trim_leading(path, "/") end defp migration_module do case Application.get_env(:ecto_sql, :migration_module, Ecto.Migration) do migration_module when is_atom(migration_module) -> migration_module other -> Mix.raise("Expected :migration_module to be a module, got: #{inspect(other)}") end end defp fixture_unique_functions(singular, uniques, attrs) do uniques |> Enum.filter(&Keyword.has_key?(attrs, &1)) |> Enum.into(%{}, fn attr -> function_name = "unique_#{singular}_#{attr}" {function_def, needs_impl?} = case Keyword.fetch!(attrs, attr) do :integer -> function_def = """ def #{function_name}, do: System.unique_integer([:positive]) """ {function_def, false} type when type in [:string, :text] -> function_def = """ def #{function_name}, do: "some #{attr}\#{System.unique_integer([:positive])}" """ {function_def, false} _ -> function_def = """ def #{function_name} do raise "implement the logic to generate a unique #{singular} #{attr}" end """ {function_def, true} end {attr, {function_name, function_def, needs_impl?}} end) end defp fixture_params(attrs, fixture_unique_functions) do attrs |> Enum.sort() |> Enum.map(fn {attr, type} -> case fixture_unique_functions do %{^attr => {function_name, _function_def, _needs_impl?}} -> {attr, "#{function_name}()"} %{} -> {attr, inspect(type_to_default(attr, type, :create))} end end) end end ================================================ FILE: lib/mix/phoenix/scope.ex ================================================ defmodule Mix.Phoenix.Scope do @moduledoc false defstruct name: nil, default: false, module: nil, alias: nil, assign_key: nil, access_path: nil, route_prefix: nil, route_access_path: nil, schema_table: nil, schema_key: nil, schema_type: nil, schema_migration_type: nil, test_data_fixture: nil, test_setup_helper: nil @doc """ Creates a new scope struct. """ def new!(name, opts) do scope = struct!(__MODULE__, opts) alias = Module.concat([scope.module |> Module.split() |> List.last()]) route_access_path = case scope.route_access_path || Enum.drop(scope.access_path, -1) do [] -> scope.access_path rap -> rap end %{ scope | name: name, alias: alias, route_access_path: route_access_path, schema_migration_type: scope.schema_migration_type || scope.schema_type } end @doc """ Returns a `%{name: scope}` map of configured scopes. """ def scopes_from_config(otp_app) do scopes = Application.get_env(otp_app, :scopes, []) Map.new(scopes, fn {name, opts} -> {name, new!(name, opts)} end) end @doc """ Returns the default scope. """ def default_scope(otp_app) do case Enum.filter(scopes_from_config(otp_app), fn {_, scope} -> scope.default end) do [{_name, scope}] -> scope [_ | _] = scopes -> Mix.raise(""" There can only be one default scope defined on your application, got: * #{Enum.map(scopes, fn {name, _scope} -> name end) |> Enum.join("\n * ")} """) [] -> nil end end @doc """ Returns the configured scope for the given --scope parameter. Returns `nil` for `--no-scope` and raises if a specific scope is not configured. """ def scope_from_opts(_otp_app, bin, false) when is_binary(bin) do Mix.raise("The --scope and --no-scope options must not be used together") end def scope_from_opts(_otp_app, _name, true), do: nil def scope_from_opts(otp_app, nil, _), do: default_scope(otp_app) def scope_from_opts(otp_app, name, _) do key = String.to_atom(name) scopes = scopes_from_config(otp_app) Map.get_lazy(scopes, key, fn -> Mix.raise(""" Scope :#{key} not configured! Ensure that the scope :#{key} is configured in your application's config: config :#{otp_app}, :scopes, [ #{key}: [ ... ] ] Note that phx.gen.auth generates a default scope for you. """) end) end @doc """ Generates a route prefix string with placeholders for the access path. Takes a scope_key (what to use for accessing the scope) and a schema with scope information. If the schema doesn't have a scope with route_prefix, returns an empty string. Otherwise, it processes the route_prefix, replacing param segments with dynamic path elements. ## Examples route_prefix("socket.assigns.current_scope", schema_with_scope) # => "/orgs/\#{socket.assigns.current_scope.organization.slug}" route_prefix("@current_scope", schema_with_scope) # => "/orgs/\#{@current_scope.organization.slug}" route_prefix("scope", schema_with_scope) # => "/orgs/\#{scope.organization.slug}" """ def route_prefix( scope_key, %{scope: %{route_prefix: route_prefix, route_access_path: route_access_path}} = _schema ) when not is_nil(route_prefix) do # Replace any path segment that starts with a colon with route_access_path from the scope path_segments = String.split(route_prefix, "/", trim: true) param_segments = Enum.filter(path_segments, &String.starts_with?(&1, ":")) if length(param_segments) > 1 do Mix.raise( "The route_prefix option in scope configuration must contain only one parameter. Found: #{inspect(param_segments)}" ) end path_with_placeholders = path_segments |> Enum.map(fn segment -> if String.starts_with?(segment, ":") do # Extract parameter name without the colon access_string = Enum.join(route_access_path, ".") "\#{#{scope_key}.#{access_string}}" else segment end end) |> Enum.join("/") "/#{path_with_placeholders}" end def route_prefix(_scope_key, _schema), do: "" end ================================================ FILE: lib/mix/phoenix.ex ================================================ defmodule Mix.Phoenix do # Conveniences for Phoenix tasks. @moduledoc false @doc """ Evals EEx files from source dir. Files are evaluated against EEx according to the given binding. """ def eval_from(apps, source_file_path, binding) do sources = Enum.map(apps, &to_app_source(&1, source_file_path)) content = Enum.find_value(sources, fn source -> File.exists?(source) && File.read!(source) end) || raise "could not find #{source_file_path} in any of the sources" EEx.eval_string(content, binding) end @doc """ Copies files from source dir to target dir according to the given map. Files are evaluated against EEx according to the given binding. """ def copy_from(apps, source_dir, binding, mapping) when is_list(mapping) do roots = Enum.map(apps, &to_app_source(&1, source_dir)) binding = Keyword.merge(binding, maybe_heex_attr_gettext: &maybe_heex_attr_gettext/2, maybe_eex_gettext: &maybe_eex_gettext/2 ) for {format, source_file_path, target} <- mapping do source = Enum.find_value(roots, fn root -> source = Path.join(root, source_file_path) # for backwards compatibility, we also check for files with missing .eex extension source_with_stripped_eex = String.replace_suffix(source, ".eex", "") cond do File.exists?(source) -> source File.exists?(source_with_stripped_eex) -> source_with_stripped_eex true -> nil end end) || raise "could not find #{source_file_path} in any of the sources" case format do :text -> Mix.Generator.create_file(target, File.read!(source)) :eex -> Mix.Generator.create_file(target, EEx.eval_file(source, binding)) :new_eex -> if File.exists?(target) do :ok else Mix.Generator.create_file(target, EEx.eval_file(source, binding)) end end end end defp to_app_source(path, source_dir) when is_binary(path), do: Path.join(path, source_dir) defp to_app_source(app, source_dir) when is_atom(app), do: Application.app_dir(app, source_dir) @doc """ Inflects path, scope, alias and more from the given name. ## Examples iex> Mix.Phoenix.inflect("user") [alias: "User", human: "User", base: "Phoenix", web_module: "PhoenixWeb", module: "Phoenix.User", scoped: "User", singular: "user", path: "user"] iex> Mix.Phoenix.inflect("Admin.User") [alias: "User", human: "User", base: "Phoenix", web_module: "PhoenixWeb", module: "Phoenix.Admin.User", scoped: "Admin.User", singular: "user", path: "admin/user"] iex> Mix.Phoenix.inflect("Admin.SuperUser") [alias: "SuperUser", human: "Super user", base: "Phoenix", web_module: "PhoenixWeb", module: "Phoenix.Admin.SuperUser", scoped: "Admin.SuperUser", singular: "super_user", path: "admin/super_user"] """ def inflect(singular) do base = Mix.Phoenix.base() web_module = base |> web_module() |> inspect() scoped = Phoenix.Naming.camelize(singular) path = Phoenix.Naming.underscore(scoped) singular = String.split(path, "/") |> List.last() module = Module.concat(base, scoped) |> inspect alias = String.split(module, ".") |> List.last() human = Phoenix.Naming.humanize(singular) [ alias: alias, human: human, base: base, web_module: web_module, module: module, scoped: scoped, singular: singular, path: path ] end @doc """ Checks the availability of a given module name. """ def check_module_name_availability!(name) do name = Module.concat(Elixir, name) if Code.ensure_loaded?(name) do Mix.raise("Module name #{inspect(name)} is already taken, please choose another name") end end @doc """ Returns the module base name based on the configuration value. config :my_app namespace: My.App """ def base do app_base(otp_app()) end @doc """ Returns the context module base name based on the configuration value. config :my_app namespace: My.App """ def context_base(ctx_app) do app_base(ctx_app) end defp app_base(app) do case Application.get_env(app, :namespace, app) do ^app -> app |> to_string() |> Phoenix.Naming.camelize() mod -> mod |> inspect() end end @doc """ Returns the OTP app from the Mix project configuration. """ def otp_app do Mix.Project.config() |> Keyword.fetch!(:app) end @doc """ Returns all compiled modules in a project. """ def modules do Mix.Project.compile_path() |> Path.join("*.beam") |> Path.wildcard() |> Enum.map(&beam_to_module/1) end defp beam_to_module(path) do path |> Path.basename(".beam") |> String.to_atom() end @doc """ The paths to look for template files for generators. Defaults to checking the current app's `priv` directory, and falls back to Phoenix's `priv` directory. """ def generator_paths do [".", :phoenix] end @doc """ Checks if the given `app_path` is inside an umbrella. """ def in_umbrella?(app_path) do umbrella = Path.expand(Path.join([app_path, "..", ".."])) mix_path = Path.join(umbrella, "mix.exs") apps_path = Path.join(umbrella, "apps") File.exists?(mix_path) && File.exists?(apps_path) end @doc """ Returns the web prefix to be used in generated file specs. """ def web_path(ctx_app, rel_path \\ "") when is_atom(ctx_app) do this_app = otp_app() if ctx_app == this_app do Path.join(["lib", "#{this_app}_web", rel_path]) else Path.join(["lib", to_string(this_app), rel_path]) end end @doc """ Returns the context app path prefix to be used in generated context files. """ def context_app_path(ctx_app, rel_path) when is_atom(ctx_app) do this_app = otp_app() if ctx_app == this_app do rel_path else app_path = case Application.get_env(this_app, :generators)[:context_app] do {^ctx_app, path} -> Path.relative_to_cwd(path) _ -> mix_app_path(ctx_app, this_app) end Path.join(app_path, rel_path) end end @doc """ Returns the context lib path to be used in generated context files. """ def context_lib_path(ctx_app, rel_path) when is_atom(ctx_app) do context_app_path(ctx_app, Path.join(["lib", to_string(ctx_app), rel_path])) end @doc """ Returns the context test path to be used in generated context files. """ def context_test_path(ctx_app, rel_path) when is_atom(ctx_app) do context_app_path(ctx_app, Path.join(["test", to_string(ctx_app), rel_path])) end @doc """ Returns the OTP context app. """ def context_app do this_app = otp_app() case fetch_context_app(this_app) do {:ok, app} -> app :error -> this_app end end @doc """ Returns the test prefix to be used in generated file specs. """ def web_test_path(ctx_app, rel_path \\ "") when is_atom(ctx_app) do this_app = otp_app() if ctx_app == this_app do Path.join(["test", "#{this_app}_web", rel_path]) else Path.join(["test", to_string(this_app), rel_path]) end end defp fetch_context_app(this_otp_app) do case Application.get_env(this_otp_app, :generators)[:context_app] do nil -> :error false -> Mix.raise(""" no context_app configured for current application #{this_otp_app}. Add the context_app generators config in config.exs, or pass the --context-app option explicitly to the generators. For example: via config: config :#{this_otp_app}, :generators, context_app: :some_app via cli option: mix phx.gen.[task] --context-app some_app Note: cli option only works when `context_app` is not set to `false` in the config. """) {app, _path} -> {:ok, app} app -> {:ok, app} end end defp mix_app_path(app, this_otp_app) do case Mix.Project.deps_paths() do %{^app => path} -> Path.relative_to_cwd(path) deps -> Mix.raise(""" no directory for context_app #{inspect(app)} found in #{this_otp_app}'s deps. Ensure you have listed #{inspect(app)} as an in_umbrella dependency in mix.exs: def deps do [ {:#{app}, in_umbrella: true}, ... ] end Existing deps: #{inspect(Map.keys(deps))} """) end end @doc """ Prompts to continue if any files exist. """ def prompt_for_conflicts(generator_files) do file_paths = Enum.flat_map(generator_files, fn {:new_eex, _, _path} -> [] {_kind, _, path} -> [path] end) case Enum.filter(file_paths, &File.exists?(&1)) do [] -> :ok conflicts -> Mix.shell().info(""" The following files conflict with new files to be generated: #{Enum.map_join(conflicts, "\n", &" * #{&1}")} See the --web option to namespace similarly named resources """) unless Mix.shell().yes?("Proceed with interactive overwrite?") do System.halt() end end end @doc """ Returns the web module prefix. """ def web_module(base) do if base |> to_string() |> String.ends_with?("Web") do Module.concat([base]) else Module.concat(["#{base}Web"]) end end def to_text(data) do inspect(data, limit: :infinity, printable_limit: :infinity) end def prepend_newline(string) do "\n" <> string end @doc """ Ensures user's LiveView is compatible with the current generators. """ def ensure_live_view_compat!(generator_mod) do vsn = Application.spec(:phoenix_live_view)[:vsn] # if lv is not installed, such as in phoenix's own test env, do not raise if vsn && Version.compare("#{vsn}", "1.0.0-rc.7") != :gt do raise "#{inspect(generator_mod)} requires :phoenix_live_view >= 1.0.0, got: #{vsn}" end end # In the context of a HEEx attribute value, transforms a given message into a # dynamic `gettext` call or a fixed-value string attribute, depending on the # `gettext?` parameter. # # ## Examples # # iex> ~s|| # ~S|| # # iex> ~s|| # ~S|| defp maybe_heex_attr_gettext(message, gettext?) do if gettext? do ~s|{gettext(#{inspect(message)})}| else inspect(message) end end # In the context of an EEx template, transforms a given message into a dynamic # `gettext` call or the message as is, depending on the `gettext?` parameter. # # ## Examples # # iex> ~s|#{maybe_eex_gettext("Hello", true)}| # ~S|<%= gettext("Hello") %>| # # iex> ~s|#{maybe_eex_gettext("Hello", false)}| # ~S|Hello| defp maybe_eex_gettext(message, gettext?) do if gettext? do ~s|<%= gettext(#{inspect(message)}) %>| else message end end end ================================================ FILE: lib/mix/tasks/compile.phoenix.ex ================================================ defmodule Mix.Tasks.Compile.Phoenix do use Mix.Task @recursive true @moduledoc false @doc false def run(_args) do IO.warn(""" the :phoenix compiler is no longer required in your mix.exs. Please find the following line in your mix.exs and remove the :phoenix entry: compilers: [..., :phoenix, ...] ++ Mix.compilers(), """) {:ok, _} = Application.ensure_all_started(:phoenix) case touch() do [] -> {:noop, []} _ -> {:ok, []} end end @doc false def touch do Mix.Phoenix.modules() |> modules_for_recompilation |> modules_to_file_paths |> Stream.map(&touch_if_exists(&1)) |> Stream.filter(&(&1 == :ok)) |> Enum.to_list() end defp touch_if_exists(path) do :file.change_time(path, :calendar.local_time()) end defp modules_for_recompilation(modules) do Stream.filter(modules, fn mod -> Code.ensure_loaded?(mod) and phoenix_recompile?(mod) end) end defp phoenix_recompile?(mod) do function_exported?(mod, :__phoenix_recompile__?, 0) and mod.__phoenix_recompile__?() end defp modules_to_file_paths(modules) do Stream.map(modules, fn mod -> mod.__info__(:compile)[:source] end) end end ================================================ FILE: lib/mix/tasks/phx.digest.clean.ex ================================================ defmodule Mix.Tasks.Phx.Digest.Clean do use Mix.Task @default_output_path "priv/static" @default_age 3600 @default_keep 2 @shortdoc "Removes old versions of static assets." @recursive true @moduledoc """ Removes old versions of compiled assets. By default, it will keep the latest version and 2 previous versions as well as any digest created in the last hour. $ mix phx.digest.clean $ mix phx.digest.clean -o /www/public $ mix phx.digest.clean --age 600 --keep 3 $ mix phx.digest.clean --all ## Options * `-o, --output` - indicates the path to your compiled assets directory. Defaults to `priv/static` * `--age` - specifies a maximum age (in seconds) for assets. Files older than age that are not in the last `--keep` versions will be removed. Defaults to 3600 (1 hour) * `--keep` - specifies how many previous versions of assets to keep. Defaults to 2 previous versions * `--all` - specifies that all compiled assets (including the manifest) will be removed. Note this overrides the age and keep switches. * `--no-compile` - do not run mix compile """ @switches [output: :string, age: :integer, keep: :integer, all: :boolean] @doc false def run(all_args) do # Ensure all compressors are compiled. if "--no-compile" not in all_args do Mix.Task.run("compile", all_args) end Mix.Task.reenable("phx.digest.clean") {:ok, _} = Application.ensure_all_started(:phoenix) {opts, _, _} = OptionParser.parse(all_args, switches: @switches, aliases: [o: :output]) output_path = opts[:output] || @default_output_path age = opts[:age] || @default_age keep = opts[:keep] || @default_keep all? = opts[:all] || false result = if all?, do: Phoenix.Digester.clean_all(output_path), else: Phoenix.Digester.clean(output_path, age, keep) case result do :ok -> # We need to call build structure so everything we have cleaned from # priv is removed from _build in case we have build_embedded set to # true. In case it's not true, build structure is mostly a no-op, so we # are fine. Mix.Project.build_structure() Mix.shell().info [:green, "Clean complete for #{inspect output_path}"] {:error, :invalid_path} -> Mix.shell().error "The output path #{inspect output_path} does not exist" end end end ================================================ FILE: lib/mix/tasks/phx.digest.ex ================================================ defmodule Mix.Tasks.Phx.Digest do use Mix.Task @default_input_path "priv/static" @shortdoc "Digests and compresses static files" @recursive true @moduledoc """ Digests and compresses static files. $ mix phx.digest $ mix phx.digest priv/static -o /www/public The first argument is the path where the static files are located. The `-o` option indicates the path that will be used to save the digested and compressed files. If no path is given, it will use `priv/static` as the input and output path. The output folder will contain: * the original file * the file compressed with gzip * a file containing the original file name and its digest * a compressed file containing the file name and its digest * a cache manifest file Example of generated files: * app.js * app.js.gz * app-eb0a5b9302e8d32828d8a73f137cc8f0.js * app-eb0a5b9302e8d32828d8a73f137cc8f0.js.gz * cache_manifest.json You can use `mix phx.digest.clean` to prune stale versions of the assets. If you want to remove all produced files, run `mix phx.digest.clean --all`. ## vsn It is possible to digest the stylesheet asset references without the query string "?vsn=d" with the option `--no-vsn`. ## Options * `-o, --output` - indicates the path to your compiled assets directory. Defaults to `priv/static` * `--no-vsn` - do not add version query string to assets * `--no-compile` - do not run mix compile """ @default_opts [vsn: true] @switches [output: :string, vsn: :boolean] @doc false def run(all_args) do # Ensure all compressors are compiled. if "--no-compile" not in all_args do Mix.Task.run("compile", all_args) end Mix.Task.reenable("phx.digest") {:ok, _} = Application.ensure_all_started(:phoenix) {opts, args, _} = OptionParser.parse(all_args, switches: @switches, aliases: [o: :output]) input_path = List.first(args) || @default_input_path output_path = opts[:output] || input_path with_vsn? = Keyword.merge(@default_opts, opts)[:vsn] case Phoenix.Digester.compile(input_path, output_path, with_vsn?) do :ok -> # We need to call build structure so everything we have # generated into priv is copied to _build in case we have # build_embedded set to true. In case it's not true, # build structure is mostly a no-op, so we are fine. Mix.Project.build_structure() Mix.shell().info [:green, "Check your digested files at #{inspect output_path}"] {:error, :invalid_path} -> # Do not exit with status code on purpose because # in an umbrella not all apps are digestable. Mix.shell().error "The input path #{inspect input_path} does not exist" end end end ================================================ FILE: lib/mix/tasks/phx.ex ================================================ defmodule Mix.Tasks.Phx do use Mix.Task @shortdoc "Prints Phoenix help information" @moduledoc """ Prints Phoenix tasks and their information. $ mix phx To print the Phoenix version, pass `-v` or `--version`, for example: $ mix phx --version """ @version Mix.Project.config()[:version] @impl true @doc false def run([version]) when version in ~w(-v --version) do Mix.shell().info("Phoenix v#{@version}") end def run(args) do case args do [] -> general() _ -> Mix.raise "Invalid arguments, expected: mix phx" end end defp general() do Application.ensure_all_started(:phoenix) Mix.shell().info "Phoenix v#{Application.spec(:phoenix, :vsn)}" Mix.shell().info "Peace of mind from prototype to production" Mix.shell().info "\n## Options\n" Mix.shell().info "-v, --version # Prints Phoenix version\n" Mix.Tasks.Help.run(["--search", "phx."]) end end ================================================ FILE: lib/mix/tasks/phx.gen.auth/hashing_library.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Auth.HashingLibrary do @moduledoc false defstruct [:name, :module, :mix_dependency, :test_config] @type t :: %__MODULE__{ name: atom(), module: module(), mix_dependency: binary(), test_config: binary() } def build("bcrypt") do lib = %__MODULE__{ name: :bcrypt, module: Bcrypt, mix_dependency: ~s|{:bcrypt_elixir, "~> 3.0"}|, test_config: """ config :bcrypt_elixir, :log_rounds, 1 """ } {:ok, lib} end def build("pbkdf2") do lib = %__MODULE__{ name: :pbkdf2, module: Pbkdf2, mix_dependency: ~s|{:pbkdf2_elixir, "~> 2.0"}|, test_config: """ config :pbkdf2_elixir, :rounds, 1 """ } {:ok, lib} end def build("argon2") do lib = %__MODULE__{ name: :argon2, module: Argon2, mix_dependency: ~s|{:argon2_elixir, "~> 4.0"}|, test_config: """ config :argon2_elixir, t_cost: 1, m_cost: 8 """ } {:ok, lib} end def build(other) do {:error, {:unknown_library, other}} end end ================================================ FILE: lib/mix/tasks/phx.gen.auth/injector.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Auth.Injector do @moduledoc false alias Mix.Phoenix.Schema alias Mix.Tasks.Phx.Gen.Auth.HashingLibrary @type schema :: %Schema{} @doc """ Injects a dependency into the contents of mix.exs """ @spec mix_dependency_inject(String.t(), String.t()) :: {:ok, String.t()} | :already_injected | {:error, :unable_to_inject} def mix_dependency_inject(mixfile, dependency) do with :ok <- ensure_not_already_injected(mixfile, dependency), {:ok, new_mixfile} <- do_mix_dependency_inject(mixfile, dependency) do {:ok, new_mixfile} end end @spec do_mix_dependency_inject(String.t(), String.t()) :: {:ok, String.t()} | {:error, :unable_to_inject} defp do_mix_dependency_inject(mixfile, dependency) do string_to_split_on = """ defp deps do [ """ case split_with_self(mixfile, string_to_split_on) do {beginning, splitter, rest} -> new_mixfile = IO.iodata_to_binary([beginning, splitter, " ", dependency, ?,, ?\n, rest]) {:ok, new_mixfile} _ -> {:error, :unable_to_inject} end end @doc """ Injects configuration into `file`. """ def config_inject(file, code_to_inject) when is_binary(file) and is_binary(code_to_inject) do inject_unless_contains( file, code_to_inject, # Matches the entire line and captures the line ending. In the # replace string: # # * the entire matching line is inserted with \\0, # * the actual code is injected with &2, # * and the appropriate newlines are injected using \\2. &Regex.replace(~r/(use Mix\.Config|import Config)(\r\n|\n|$)/, &1, "\\0\\2#{&2}\\2", global: false ) ) end @doc """ Injects configuration for test environment into `file`. """ @spec test_config_inject(String.t(), HashingLibrary.t()) :: {:ok, String.t()} | :already_injected | {:error, :unable_to_inject} def test_config_inject(file, %HashingLibrary{} = hashing_library) when is_binary(file) do code_to_inject = hashing_library |> test_config_code() |> normalize_line_endings_to_file(file) config_inject(file, code_to_inject) end @doc """ Instructions to provide the user when `test_config_inject/2` fails. """ @spec test_config_help_text(String.t(), HashingLibrary.t()) :: String.t() def test_config_help_text(file_path, %HashingLibrary{} = hashing_library) do """ Add the following to #{Path.relative_to_cwd(file_path)}: #{hashing_library |> test_config_code() |> indent_spaces(4)} """ end defp test_config_code(%HashingLibrary{test_config: test_config}) do String.trim(""" # Only in tests, remove the complexity from the password hashing algorithm #{test_config} """) end @router_plug_anchor_line "plug :put_secure_browser_headers" @doc """ Injects the fetch_current_scope_for_ plug into router's browser pipeline """ @spec router_plug_inject(String.t(), binding :: keyword()) :: {:ok, String.t()} | :already_injected | {:error, :unable_to_inject} def router_plug_inject(file, binding) when is_binary(file) do inject_unless_contains( file, router_plug_code(binding), # Matches the entire line containing `anchor_line` and captures # the whitespace before the anchor. In the replace string # # * the entire matching line is inserted with \\0, # * the captured indent is inserted using \\1, # * the actual code is injected with &2, # * and the appropriate newline is injected using \\2 &Regex.replace(~r/^(\s*)#{@router_plug_anchor_line}.*(\r\n|\n|$)/Um, &1, "\\0\\1#{&2}\\2", global: false ) ) end @doc """ Instructions to provide the user when `inject_router_plug/2` fails. """ @spec router_plug_help_text(String.t(), binding :: keyword()) :: String.t() def router_plug_help_text(file_path, binding) do """ Add the #{router_plug_name(binding)} plug to the :browser pipeline in #{Path.relative_to_cwd(file_path)}: pipeline :browser do ... #{@router_plug_anchor_line} #{router_plug_code(binding)} end """ end defp router_plug_code(binding) do "plug " <> router_plug_name(binding) end defp router_plug_name(binding) do ":fetch_#{binding[:scope_config].scope.assign_key}_for_#{binding[:schema].singular}" end @doc """ Injects a menu in the application layout """ def app_layout_menu_inject(binding, template_str) do with {:error, :unable_to_inject} <- app_layout_menu_inject_at_end_of_nav_tag(binding, template_str), {:error, :unable_to_inject} <- app_layout_menu_inject_after_opening_body_tag(binding, template_str) do {:error, :unable_to_inject} end end @doc """ Instructions to provide the user when `app_layout_menu_inject/2` fails. """ def app_layout_menu_help_text(file_path, binding) do {_dup_check, code} = app_layout_menu_code_to_inject(binding) """ Add the following #{binding[:schema].singular} menu items to your #{Path.relative_to_cwd(file_path)} layout file: #{code} """ end @doc """ Menu code to inject into the application layout template. """ def app_layout_menu_code_to_inject(binding, padding \\ 4, newline \\ "\n") do schema = binding[:schema] scope_config = binding[:scope_config] already_injected_str = "#{schema.route_prefix}/log-in" template = """
    <%= if @#{scope_config.scope.assign_key} do %>
  • {@#{scope_config.scope.assign_key}.#{schema.singular}.email}
  • <.link href={~p"#{schema.route_prefix}/settings"}>Settings
  • <.link href={~p"#{schema.route_prefix}/log-out"} method="delete">Log out
    • <% else %>
  • <.link href={~p"#{schema.route_prefix}/register"}>Register
  • <.link href={~p"#{schema.route_prefix}/log-in"}>Log in
    • <% end %>
\ """ {already_injected_str, indent_spaces(template, padding, newline)} end defp formatting_info(template, tag) do {padding, newline} = case Regex.run(~r/ {String.trim_leading(pre, "\n") <> " ", "\n"} [_, "\r\n" <> pre, "\r"] -> {String.trim_leading(pre, "\r\n") <> " ", "\r\n"} _ -> {"", "\n"} end {String.length(padding), newline} end defp app_layout_menu_inject_at_end_of_nav_tag(binding, file) do {padding, newline} = formatting_info(file, "<\/nav>") {dup_check, code} = app_layout_menu_code_to_inject(binding, padding, newline) inject_unless_contains( file, dup_check, code, &Regex.replace(~r/(\s*)<\/nav>/m, &1, "#{newline}#{&2}\\0", global: false) ) end defp app_layout_menu_inject_after_opening_body_tag(binding, file) do anchor_line = " String.trim_trailing() |> String.trim_trailing("end") |> Kernel.<>(code_to_inject) |> Kernel.<>("end\n") {:ok, new_code} end end @spec ensure_not_already_injected(String.t(), String.t()) :: :ok | :already_injected defp ensure_not_already_injected(file, inject) do if String.contains?(file, inject) do :already_injected else :ok end end @spec split_with_self(String.t(), String.t()) :: {String.t(), String.t(), String.t()} | :error defp split_with_self(contents, text) do case :binary.split(contents, text) do [left, right] -> {left, text, right} [_] -> :error end end @spec normalize_line_endings_to_file(String.t(), String.t()) :: String.t() defp normalize_line_endings_to_file(code, file) do String.replace(code, "\n", get_line_ending(file)) end @spec get_line_ending(String.t()) :: String.t() defp get_line_ending(file) do case Regex.run(~r/\r\n|\n|$/, file) do [line_ending] -> line_ending [] -> "\n" end end defp indent_spaces(string, number_of_spaces, newline \\ "\n") when is_binary(string) and is_integer(number_of_spaces) do indent = String.duplicate(" ", number_of_spaces) string |> String.split("\n") |> Enum.map_join(newline, &(indent <> &1)) end end ================================================ FILE: lib/mix/tasks/phx.gen.auth/migration.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Auth.Migration do @moduledoc false defstruct [:ecto_adapter, :extensions, :column_definitions] def build(ecto_adapter) when is_atom(ecto_adapter) do %__MODULE__{ ecto_adapter: ecto_adapter, extensions: extensions(ecto_adapter), column_definitions: column_definitions(ecto_adapter) } end defp extensions(Ecto.Adapters.Postgres) do ["execute \"CREATE EXTENSION IF NOT EXISTS citext\", \"\""] end defp extensions(_), do: [] defp column_definitions(ecto_adapter) do for field <- ~w(email token)a, into: %{}, do: {field, column_definition(field, ecto_adapter)} end defp column_definition(:email, Ecto.Adapters.Postgres), do: "add :email, :citext, null: false" defp column_definition(:email, Ecto.Adapters.SQLite3), do: "add :email, :string, null: false, collate: :nocase" defp column_definition(:email, _), do: "add :email, :string, null: false, size: 160" defp column_definition(:token, Ecto.Adapters.Postgres), do: "add :token, :binary, null: false" defp column_definition(:token, _), do: "add :token, :binary, null: false, size: 32" end ================================================ FILE: lib/mix/tasks/phx.gen.auth.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Auth do @shortdoc "Generates authentication logic for a resource" @moduledoc """ Generates authentication logic and related views for a resource. ```console $ mix phx.gen.auth Accounts User users ``` The first argument is the context module followed by the schema module and its plural name (used as the schema table name). The example above will generate an `Accounts` context module with two schemas inside: `User` and `UserToken`. You may name the context and schema according to your preferences. For example: ```console $ mix phx.gen.auth Identity Client clients ``` Will generate an `Identity` context with `Client` and `ClientToken` inside. Additional information and security considerations are detailed in the [`mix phx.gen.auth` guide](mix_phx_gen_auth.html). > #### A note on scopes {: .info} > > `mix phx.gen.auth` creates a scope named after the schema by default. > You can read more about scopes in the [Scopes guide](scopes.html). ## LiveView vs conventional Controllers & Views Authentication views can either be generated to use LiveView by passing the `--live` option, or they can use conventional Phoenix Controllers & Views by passing `--no-live`. If neither of these options are provided, a prompt will be displayed. Using the `--live` option is advised if you plan on using LiveView elsewhere in your application. The user experience when navigating between LiveViews can be tightly controlled, allowing you to let your users navigate to authentication views without necessarily triggering a new HTTP request each time (which would result in a full page load). ## Mixing magic link and password registration `mix phx.gen.auth` generates email based authentication, which assumes the user who owns the email address has control over the account. Therefore, it is extremely important to void all access tokens once the user confirms their account for the first time, and we do so by revoking all tokens upon confirmation. However, if you allow users to create an account with password, you must also require them to be logged in by the time of confirmation, otherwise you may be vulnerable to credential pre-stuffing, as the following attack is possible: 1. An attacker registers a new account with the email address of their target, anticipating that the target creates an account at a later point in time. 2. The attacker sets a password when registering. 3. The target registers an account and sees that their email address is already in use. 4. The target logs in by magic link, but does not change the existing password. 5. The attacker maintains access using the password they previously set. This is why the default implementation raises whenever a user tries to log in for the first time by magic link and there is a password set. If you add registration with email and password, then you must require the user to be logged in to confirm their account. If they don't have a password (because it was set by the attacker), then they can set one via a "Forgot your password?"-like workflow. ## Password hashing The password hashing mechanism defaults to `bcrypt` for Unix systems and `pbkdf2` for Windows systems. Both systems use the [Comeonin interface](https://hexdocs.pm/comeonin/). The password hashing mechanism can be overridden with the `--hashing-lib` option. The following values are supported: * `bcrypt` - [bcrypt_elixir](https://hex.pm/packages/bcrypt_elixir) * `pbkdf2` - [pbkdf2_elixir](https://hex.pm/packages/pbkdf2_elixir) * `argon2` - [argon2_elixir](https://hex.pm/packages/argon2_elixir) We recommend developers to consider using `argon2`, which is the most robust of all 3. The downside is that `argon2` is quite CPU and memory intensive, and you will need more powerful instances to run your applications on. For more information about choosing these libraries, see the [Comeonin project](https://github.com/riverrun/comeonin). ## Multiple invocations You can invoke this generator multiple times. This is typically useful if you have distinct resources that go through distinct authentication workflows: $ mix phx.gen.auth Store User users $ mix phx.gen.auth Backoffice Admin admins Note that when invoking `phx.gen.auth` multiple times, it will also generate multiple [scopes](guides/authn_authz/scopes.md). Typically, only one scope is needed, thus you will probably want to customize the generated code afterwards. Also, it is expected that the generated code is not fully free of conflicts. One example is the browser pipeline, which will try to assign both scopes as `:current_scope` by default. You can customize the generated assign key with the `--assign-key` option. ## Binary ids The `--binary-id` option causes the generated migration to use `binary_id` for its primary key and foreign keys. ## Default options This generator uses default options provided in the `:generators` configuration of your application. These are the defaults: config :your_app, :generators, binary_id: false, sample_binary_id: "11111111-1111-1111-1111-111111111111" You can override those options per invocation by providing corresponding switches, e.g. `--no-binary-id` to use normal ids despite the default configuration. ## Custom table names By default, the table name for the migration and schema will be the plural name provided for the resource. To customize this value, a `--table` option may be provided. For example: $ mix phx.gen.auth Accounts User users --table accounts_users This will cause the generated tables to be named `"accounts_users"` and `"accounts_users_tokens"`. ## Custom scope name By default, the scope name is the same as the schema name. You can customize the scope name by passing the `--scope` option. For example: ```console $ mix phx.gen.auth Accounts User users --scope app_user ``` This will generate a scope named `app_user` instead of `user`. You can read more about scopes in the [Scopes guide](scopes.html). Additionally, the scope's assign key can be customized by passing the `--assign-key` option. For example: ```console $ mix phx.gen.auth Accounts User users --assign-key current_user_scope ``` This is useful when you want to run `mix phx.gen.auth` multiple times in the same project, but note that often it might make more sense to reuse the same scope with additional fields instead of separate scopes. """ use Mix.Task alias Mix.Phoenix.{Context, Schema} alias Mix.Tasks.Phx.Gen alias Mix.Tasks.Phx.Gen.Auth.{HashingLibrary, Injector, Migration} @switches [ web: :string, binary_id: :boolean, hashing_lib: :string, table: :string, merge_with_existing_context: :boolean, prefix: :string, live: :boolean, compile: :boolean, scope: :string, assign_key: :string, agents_md: :boolean ] @doc false def run(args, test_opts \\ []) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.auth must be invoked from within your *_web application root directory" ) end Mix.Phoenix.ensure_live_view_compat!(__MODULE__) {opts, parsed} = OptionParser.parse!(args, strict: @switches) validate_args!(parsed) hashing_library = build_hashing_library!(opts) context_args = OptionParser.to_argv(Keyword.drop(opts, [:scope, :assign_key, :agents_md]), switches: @switches ) ++ parsed {context, schema} = Gen.Context.build(context_args ++ ["--no-scope"], help_module: __MODULE__) context = put_live_option(context) Gen.Context.prompt_for_code_injection(context) if "--no-compile" not in args do # Needed so we can get the ecto adapter and ensure other # libraries are loaded. Mix.Task.run("compile") validate_required_dependencies!() end ecto_adapter = Keyword.get_lazy( test_opts, :ecto_adapter, fn -> get_ecto_adapter!(schema) end ) migration = Migration.build(ecto_adapter) binding = [ context: context, schema: schema, migration: migration, hashing_library: hashing_library, web_app_name: web_app_name(context), web_namespace: context.web_module, endpoint_module: Module.concat([context.web_module, Endpoint]), auth_module: Module.concat([context.web_module, schema.web_namespace, "#{inspect(schema.alias)}Auth"]), router_scope: router_scope(context), web_path_prefix: web_path_prefix(schema), test_case_options: test_case_options(ecto_adapter), live?: Keyword.fetch!(context.opts, :live), datetime_module: datetime_module(schema), datetime_now: datetime_now(schema), scope_config: scope_config(context, opts[:scope], Keyword.get(opts, :assign_key, "current_scope")), agents_md: Keyword.get(opts, :agents_md, true) ] paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(binding) context |> copy_new_files(binding, paths) |> inject_conn_case_helpers(paths, binding) |> inject_hashing_config(hashing_library) |> maybe_inject_scope_config(binding) |> maybe_inject_mix_dependency(hashing_library) |> inject_routes(paths, binding) |> maybe_inject_router_import(binding) |> maybe_inject_router_plug(binding) |> maybe_inject_app_layout_menu(binding) |> maybe_inject_agents_md(paths, binding) |> Gen.Notifier.maybe_print_mailer_installation_instructions() |> print_shell_instructions() end defp web_app_name(%Context{} = context) do context.web_module |> inspect() |> Phoenix.Naming.underscore() end defp validate_args!([_, _, _]), do: :ok defp validate_args!(_) do raise_with_help("Invalid arguments") end defp validate_required_dependencies! do unless Code.ensure_loaded?(Ecto.Adapters.SQL) do raise_with_help("mix phx.gen.auth requires ecto_sql", :phx_generator_args) end if generated_with_no_html?() do raise_with_help("mix phx.gen.auth requires phoenix_html", :phx_generator_args) end if generated_with_no_assets_or_esbuild?() do Mix.shell().yes?(""" Warning: did not find phoenix_html in your app.js. phx.gen.auth expects the phoenix_html JavaScript to be available in your application for the generated logout link to work. This is not the case for applications generated with `--no-assets` or `--no-esbuild`. To make the logout link work, you'll need to manually add the phoenix_html JavaScript to your application. It is available at the "priv/static/phoenix_html" path of the phoenix_html application. Alternatively, you can refactor the logout link to submit a `
` with method "delete" instead. Continue?\ """) || System.halt() end end defp generated_with_no_html? do Mix.Project.config() |> Keyword.get(:deps, []) |> Enum.any?(fn {:phoenix_html, _} -> true {:phoenix_html, _, _} -> true _ -> false end) |> Kernel.not() end defp generated_with_no_assets_or_esbuild? do not Code.ensure_loaded?(Phoenix.HTML) or case File.read("assets/js/app.js") do {:ok, content} -> content =~ "priv/static/phoenix_html.js" {:error, _} -> true end end defp build_hashing_library!(opts) do opts |> Keyword.get_lazy(:hashing_lib, &default_hashing_library_option/0) |> HashingLibrary.build() |> case do {:ok, hashing_library} -> hashing_library {:error, {:unknown_library, unknown_library}} -> raise_with_help( "Unknown value for --hashing-lib #{inspect(unknown_library)}", :hashing_lib ) end end defp default_hashing_library_option do case :os.type() do {:unix, _} -> "bcrypt" {:win32, _} -> "pbkdf2" end end defp scope_config(context, requested_scope, assign_key) do existing_scopes = Mix.Phoenix.Scope.scopes_from_config(context.context_app) {_, default_scope} = Enum.find(existing_scopes, {nil, nil}, fn {_, scope} -> scope.default end) key = String.to_atom(requested_scope || find_scope_name(context, existing_scopes)) {create_new?, scope, config_string} = if Map.has_key?(existing_scopes, key) do {false, existing_scopes[key], nil} else {true, new_scope(context, key, default_scope, assign_key), scope_config_string(context, key, default_scope, assign_key)} end %{ scopes: existing_scopes, default_scope: default_scope, create_new?: create_new?, scope: scope, config_string: config_string } end defp find_scope_name(context, existing_scopes) do cond do # user is_new_scope?(existing_scopes, context.schema.singular) -> context.schema.singular # accounts_user is_new_scope?(existing_scopes, "#{context.basename}_#{context.schema.singular}") -> "#{context.basename}_#{context.schema.singular}" # my_app_accounts_user is_new_scope?( existing_scopes, "#{context.context_app}_#{context.basename}_#{context.schema.singular}" ) -> "#{context.context_app}_#{context.basename}_#{context.schema.singular}" true -> Mix.raise(""" Could not generate a scope name for #{context.schema.singular}! These scopes already exist: * #{Enum.map(existing_scopes, fn {name, _scope} -> name end) |> Enum.join("\n * ")} You can customize the scope name by passing the --scope option. """) end end defp is_new_scope?(existing_scopes, bin_key) do key = String.to_atom(bin_key) not Map.has_key?(existing_scopes, key) end defp new_scope(context, key, default_scope, assign_key) do Mix.Phoenix.Scope.new!(key, %{ default: !default_scope, module: Module.concat([context.module, "Scope"]), assign_key: String.to_atom(assign_key), access_path: [ String.to_atom(context.schema.singular), context.schema.opts[:primary_key] || :id ], schema_key: String.to_atom("#{context.schema.singular}_#{context.schema.opts[:primary_key] || :id}"), schema_type: if(context.schema.binary_id, do: :binary_id, else: :id), schema_table: context.schema.table, test_data_fixture: Module.concat([context.module, "Fixtures"]), test_setup_helper: :"register_and_log_in_#{context.schema.singular}" }) end defp scope_config_string(context, key, default_scope, assign_key) do """ config :#{context.context_app}, :scopes, #{key}: [ default: #{if default_scope, do: false, else: true}, module: #{inspect(context.module)}.Scope, assign_key: :#{assign_key}, access_path: [:#{context.schema.singular}, :#{context.schema.opts[:primary_key] || :id}], schema_key: :#{context.schema.singular}_#{context.schema.opts[:primary_key] || :id}, schema_type: :#{if(context.schema.binary_id, do: :binary_id, else: :id)}, schema_table: :#{context.schema.table}, test_data_fixture: #{inspect(context.module)}Fixtures, test_setup_helper: :register_and_log_in_#{context.schema.singular} ]\ """ end defp prompt_for_conflicts(binding) do prompt_for_scope_conflicts(binding) binding |> files_to_be_generated() |> Mix.Phoenix.prompt_for_conflicts() end defp prompt_for_scope_conflicts(binding) do schema = binding[:schema] %{scope: scope, default_scope: default_scope, create_new?: new?} = binding[:scope_config] cond do # this can only happen if --scope is used and the user explicitly asked for the scope name scope && not new? -> Mix.shell().yes?(""" The scope #{scope.name} is already configured. phx.gen.auth expects the configured scope module #{inspect(scope.module)} to include a `for_#{schema.singular}/1` function that returns a `%#{inspect(schema.module)}{}` struct: def for_#{schema.singular}(nil), do: %__MODULE__{user: nil} def for_#{schema.singular}(%<%= inspect schema.alias %>{} = #{schema.singular}) do %__MODULE__{#{schema.singular}: #{schema.singular}} end Please ensure that your scope module includes such code. Do you want to proceed with the generation?\ """) || System.halt() default_scope -> Mix.shell().yes?(""" Your application configuration already contains a default scope: #{inspect(default_scope.name)}. phx.gen.auth will create a new #{scope.name} scope. Note that if you run `phx.gen.live` multiple times, the generated assign key for the generated scopes can conflict with each other. You can pass `--assign-key` to customize the assign key for the generated scope. Do you want to proceed with the generation?\ """) || System.halt() true -> :ok end end defp files_to_be_generated(binding) do schema = binding[:schema] context = binding[:context] context_app = context.context_app scope_config = binding[:scope_config] singular = schema.singular web_pre = Mix.Phoenix.web_path(context_app) web_test_pre = Mix.Phoenix.web_test_path(context_app) migrations_pre = Mix.Phoenix.context_app_path(context_app, "priv/repo/migrations") web_path = to_string(schema.web_path) controller_pre = Path.join([web_pre, "controllers", web_path]) default_files = [ "migration.ex.eex": [migrations_pre, "#{timestamp()}_create_#{schema.table}_auth_tables.exs"], "notifier.ex.eex": [context.dir, "#{singular}_notifier.ex"], "schema.ex.eex": [context.dir, "#{singular}.ex"], "schema_token.ex.eex": [context.dir, "#{singular}_token.ex"], "auth.ex.eex": [web_pre, web_path, "#{singular}_auth.ex"], "auth_test.exs.eex": [web_test_pre, web_path, "#{singular}_auth_test.exs"], "session_controller.ex.eex": [controller_pre, "#{singular}_session_controller.ex"], "session_controller_test.exs.eex": [ web_test_pre, "controllers", web_path, "#{singular}_session_controller_test.exs" ] ] ++ if scope_config.create_new? do ["scope.ex.eex": [context.dir, "scope.ex"]] else [] end case Keyword.fetch(context.opts, :live) do {:ok, true} -> live_files = [ "registration_live.ex.eex": [ web_pre, "live", web_path, "#{singular}_live", "registration.ex" ], "registration_live_test.exs.eex": [ web_test_pre, "live", web_path, "#{singular}_live", "registration_test.exs" ], "login_live.ex.eex": [web_pre, "live", web_path, "#{singular}_live", "login.ex"], "login_live_test.exs.eex": [ web_test_pre, "live", web_path, "#{singular}_live", "login_test.exs" ], "settings_live.ex.eex": [web_pre, "live", web_path, "#{singular}_live", "settings.ex"], "settings_live_test.exs.eex": [ web_test_pre, "live", web_path, "#{singular}_live", "settings_test.exs" ], "confirmation_live.ex.eex": [ web_pre, "live", web_path, "#{singular}_live", "confirmation.ex" ], "confirmation_live_test.exs.eex": [ web_test_pre, "live", web_path, "#{singular}_live", "confirmation_test.exs" ] ] remap_files(default_files ++ live_files) _ -> non_live_files = [ "registration_new.html.heex.eex": [ controller_pre, "#{singular}_registration_html", "new.html.heex" ], "registration_controller.ex.eex": [controller_pre, "#{singular}_registration_controller.ex"], "registration_controller_test.exs.eex": [ web_test_pre, "controllers", web_path, "#{singular}_registration_controller_test.exs" ], "registration_html.ex.eex": [controller_pre, "#{singular}_registration_html.ex"], "session_html.ex.eex": [controller_pre, "#{singular}_session_html.ex"], "session_new.html.heex.eex": [controller_pre, "#{singular}_session_html", "new.html.heex"], "session_confirm.html.heex.eex": [ controller_pre, "#{singular}_session_html", "confirm.html.heex" ], "settings_html.ex.eex": [web_pre, "controllers", web_path, "#{singular}_settings_html.ex"], "settings_controller.ex.eex": [controller_pre, "#{singular}_settings_controller.ex"], "settings_edit.html.heex.eex": [ controller_pre, "#{singular}_settings_html", "edit.html.heex" ], "settings_controller_test.exs.eex": [ web_test_pre, "controllers", web_path, "#{singular}_settings_controller_test.exs" ] ] remap_files(default_files ++ non_live_files) end end defp remap_files(files) do for {source, dest} <- files, do: {:eex, to_string(source), Path.join(dest)} end defp copy_new_files(%Context{} = context, binding, paths) do files = files_to_be_generated(binding) Mix.Phoenix.copy_from(paths, "priv/templates/phx.gen.auth", binding, files) inject_context_functions(context, paths, binding) inject_tests(context, paths, binding) inject_context_test_fixtures(context, paths, binding) context end defp inject_context_functions(%Context{file: file} = context, paths, binding) do Gen.Context.ensure_context_file_exists(context, paths, binding) paths |> Mix.Phoenix.eval_from("priv/templates/phx.gen.auth/context_functions.ex.eex", binding) |> prepend_newline() |> inject_before_final_end(file) end defp inject_tests(%Context{test_file: test_file} = context, paths, binding) do Gen.Context.ensure_test_file_exists(context, paths, binding) paths |> Mix.Phoenix.eval_from("priv/templates/phx.gen.auth/test_cases.exs.eex", binding) |> prepend_newline() |> inject_before_final_end(test_file) end defp inject_context_test_fixtures( %Context{test_fixtures_file: test_fixtures_file} = context, paths, binding ) do Gen.Context.ensure_test_fixtures_file_exists(context, paths, binding) paths |> Mix.Phoenix.eval_from("priv/templates/phx.gen.auth/context_fixtures_functions.ex.eex", binding) |> prepend_newline() |> inject_before_final_end(test_fixtures_file) end defp inject_conn_case_helpers(%Context{} = context, paths, binding) do test_file = "test/support/conn_case.ex" paths |> Mix.Phoenix.eval_from("priv/templates/phx.gen.auth/conn_case.exs.eex", binding) |> inject_before_final_end(test_file) context end defp inject_routes(%Context{context_app: ctx_app} = context, paths, binding) do web_prefix = Mix.Phoenix.web_path(ctx_app) file_path = Path.join(web_prefix, "router.ex") paths |> Mix.Phoenix.eval_from("priv/templates/phx.gen.auth/routes.ex.eex", binding) |> inject_before_final_end(file_path) context end defp maybe_inject_mix_dependency(%Context{context_app: ctx_app} = context, %HashingLibrary{ mix_dependency: mix_dependency }) do file_path = Mix.Phoenix.context_app_path(ctx_app, "mix.exs") file = File.read!(file_path) case Injector.mix_dependency_inject(file, mix_dependency) do {:ok, new_file} -> print_injecting(file_path) File.write!(file_path, new_file) :already_injected -> :ok {:error, :unable_to_inject} -> Mix.shell().info(""" Add your #{mix_dependency} dependency to #{file_path}: defp deps do [ #{mix_dependency}, ... ] end """) end context end defp maybe_inject_router_import(%Context{context_app: ctx_app} = context, binding) do web_prefix = Mix.Phoenix.web_path(ctx_app) file_path = Path.join(web_prefix, "router.ex") auth_module = Keyword.fetch!(binding, :auth_module) inject = "import #{inspect(auth_module)}" use_line = "use #{inspect(context.web_module)}, :router" help_text = """ Add your #{inspect(auth_module)} import to #{Path.relative_to_cwd(file_path)}: defmodule #{inspect(context.web_module)}.Router do #{use_line} # Import authentication plugs #{inject} ... end """ with {:ok, file} <- read_file(file_path), {:ok, new_file} <- Injector.inject_unless_contains( file, inject, &String.replace(&1, use_line, "#{use_line}\n\n #{&2}") ) do print_injecting(file_path, " - imports") File.write!(file_path, new_file) else :already_injected -> :ok {:error, :unable_to_inject} -> Mix.shell().info(""" #{help_text} """) {:error, {:file_read_error, _}} -> print_injecting(file_path) print_unable_to_read_file_error(file_path, help_text) end context end defp maybe_inject_router_plug(%Context{context_app: ctx_app} = context, binding) do web_prefix = Mix.Phoenix.web_path(ctx_app) file_path = Path.join(web_prefix, "router.ex") help_text = Injector.router_plug_help_text(file_path, binding) with {:ok, file} <- read_file(file_path), {:ok, new_file} <- Injector.router_plug_inject(file, binding) do print_injecting(file_path, " - plug") File.write!(file_path, new_file) else :already_injected -> :ok {:error, :unable_to_inject} -> Mix.shell().info(""" #{help_text} """) {:error, {:file_read_error, _}} -> print_injecting(file_path) print_unable_to_read_file_error(file_path, help_text) end context end defp maybe_inject_app_layout_menu(%Context{} = context, binding) do if file_path = get_layout_html_path(context) do case Injector.app_layout_menu_inject(binding, File.read!(file_path)) do {:ok, new_content} -> print_injecting(file_path) File.write!(file_path, new_content) :already_injected -> :ok {:error, :unable_to_inject} -> Mix.shell().info(""" #{Injector.app_layout_menu_help_text(file_path, binding)} """) end else {_dup, inject} = Injector.app_layout_menu_code_to_inject(binding) missing = context |> potential_layout_file_paths() |> Enum.map_join("\n", &" * #{&1}") Mix.shell().error(""" Unable to find the root layout file to inject user menu items. Missing files: #{missing} Please ensure this phoenix app was not generated with --no-html. If you have changed the name of your root layout file, please add the following code to it where you'd like the #{binding[:schema].singular} menu items to be rendered. #{inject} """) end context end defp get_layout_html_path(%Context{} = context) do context |> potential_layout_file_paths() |> Enum.find(&File.exists?/1) end defp potential_layout_file_paths(%Context{context_app: ctx_app}) do web_prefix = Mix.Phoenix.web_path(ctx_app) for file_name <- ~w(root.html.heex) do Path.join([web_prefix, "components", "layouts", file_name]) end end defp inject_hashing_config(context, %HashingLibrary{} = hashing_library) do file_path = if Mix.Phoenix.in_umbrella?(File.cwd!()) do Path.expand("../../") else File.cwd!() end |> Path.join("config/test.exs") file = case read_file(file_path) do {:ok, file} -> file {:error, {:file_read_error, _}} -> "import Config\n" end case Injector.test_config_inject(file, hashing_library) do {:ok, new_file} -> print_injecting(file_path) File.write!(file_path, new_file) :already_injected -> :ok {:error, :unable_to_inject} -> help_text = Injector.test_config_help_text(file_path, hashing_library) Mix.shell().info(""" #{help_text} """) end context end defp maybe_inject_scope_config(%Context{} = context, binding) do if binding[:scope_config].create_new? do inject_scope_config(context, binding) else context end end defp inject_scope_config(%Context{} = context, binding) do scope_config = binding[:scope_config].config_string file_path = if Mix.Phoenix.in_umbrella?(File.cwd!()) do Path.expand("../../") else File.cwd!() end |> Path.join("config/config.exs") file = case read_file(file_path) do {:ok, file} -> file {:error, {:file_read_error, _}} -> "import Config\n" end case Injector.config_inject(file, scope_config) do {:ok, new_file} -> print_injecting(file_path) File.write!(file_path, new_file) :already_injected -> :ok {:error, :unable_to_inject} -> Mix.shell().info(""" Add the following to #{Path.relative_to_cwd(file_path)}: #{scope_config} """) end context end defp maybe_inject_agents_md(%Context{} = context, paths, binding) do if binding[:agents_md] do # we add our own comment marker (not related to usage_rules) # to check if phx.gen.auth already ran as we only want to inject once # even if other options were used auth_content = """ #{Mix.Phoenix.eval_from(paths, "priv/templates/phx.gen.auth/AGENTS.md.eex", binding)} """ file_path = if Mix.Phoenix.in_umbrella?(File.cwd!()) do Path.expand("../../") else File.cwd!() end |> Path.join("AGENTS.md") with true <- File.exists?(file_path), content = File.read!(file_path), false <- content =~ "" do print_injecting(file_path) # inject before usage rules case String.split(content, "", parts: 2) do [pre, post] -> File.write!(file_path, [ pre, String.trim_trailing(auth_content), "\n\n", "", post ]) _ -> # just append File.write!(file_path, content <> "\n\n" <> String.trim_trailing(auth_content)) end end end context end defp print_shell_instructions(%Context{} = context) do Mix.shell().info(""" Please re-fetch your dependencies with the following command: $ mix deps.get Remember to update your repository by running migrations: $ mix ecto.migrate Once you are ready, visit "/#{context.schema.plural}/register" to create your account and then access "/dev/mailbox" to see the account confirmation email. """) context end defp router_scope(%Context{schema: schema} = context) do prefix = Module.concat(context.web_module, schema.web_namespace) if schema.web_namespace do ~s|"/#{schema.web_path}", #{inspect(prefix)}| else ~s|"/", #{inspect(context.web_module)}| end end defp web_path_prefix(%Schema{web_path: nil}), do: "" defp web_path_prefix(%Schema{web_path: web_path}), do: "/" <> web_path defp inject_before_final_end(content_to_inject, file_path) do with {:ok, file} <- read_file(file_path), {:ok, new_file} <- Injector.inject_before_final_end(file, content_to_inject) do print_injecting(file_path) File.write!(file_path, new_file) else :already_injected -> :ok {:error, {:file_read_error, _}} -> print_injecting(file_path) print_unable_to_read_file_error( file_path, """ Please add the following to the end of your equivalent #{Path.relative_to_cwd(file_path)} module: #{indent_spaces(content_to_inject, 2)} """ ) end end defp read_file(file_path) do case File.read(file_path) do {:ok, file} -> {:ok, file} {:error, reason} -> {:error, {:file_read_error, reason}} end end defp indent_spaces(string, number_of_spaces) when is_binary(string) and is_integer(number_of_spaces) do indent = String.duplicate(" ", number_of_spaces) string |> String.split("\n") |> Enum.map_join("\n", &(indent <> &1)) end defp timestamp do {{y, m, d}, {hh, mm, ss}} = :calendar.universal_time() "#{y}#{pad(m)}#{pad(d)}#{pad(hh)}#{pad(mm)}#{pad(ss)}" end defp pad(i) when i < 10, do: <> defp pad(i), do: to_string(i) defp prepend_newline(string) when is_binary(string), do: "\n" <> string defp get_ecto_adapter!(%Schema{repo: repo}) do if Code.ensure_loaded?(repo) do repo.__adapter__() else Mix.raise("Unable to find #{inspect(repo)}") end end defp print_injecting(file_path, suffix \\ []) do Mix.shell().info([:green, "* injecting ", :reset, Path.relative_to_cwd(file_path), suffix]) end defp print_unable_to_read_file_error(file_path, help_text) do Mix.shell().error( """ Unable to read file #{Path.relative_to_cwd(file_path)}. #{help_text} """ |> indent_spaces(2) ) end @doc false def raise_with_help(msg) do raise_with_help(msg, :general) end defp raise_with_help(msg, :general) do Mix.raise(""" #{msg} mix phx.gen.auth expects a context module name, followed by the schema module and its plural name (used as the schema table name). For example: mix phx.gen.auth Accounts User users The context serves as the API boundary for the given resource. Multiple resources may belong to a context and a resource may be split over distinct contexts (such as Accounts.User and Payments.User). """) end defp raise_with_help(msg, :phx_generator_args) do Mix.raise(""" #{msg} mix phx.gen.auth must be installed into a Phoenix 1.5 app that contains ecto and html templates. mix phx.new my_app mix phx.new my_app --umbrella mix phx.new my_app --database mysql Apps generated with --no-ecto or --no-html are not supported. """) end defp raise_with_help(msg, :hashing_lib) do Mix.raise(""" #{msg} mix phx.gen.auth supports the following values for --hashing-lib * bcrypt * pbkdf2 * argon2 Visit https://github.com/riverrun/comeonin for more information on choosing a library. """) end defp test_case_options(Ecto.Adapters.Postgres), do: ", async: true" defp test_case_options(adapter) when is_atom(adapter), do: "" defp datetime_module(%{timestamp_type: :naive_datetime}), do: NaiveDateTime defp datetime_module(%{timestamp_type: :utc_datetime}), do: DateTime defp datetime_module(%{timestamp_type: :utc_datetime_usec}), do: DateTime defp datetime_now(%{timestamp_type: :naive_datetime}), do: "NaiveDateTime.utc_now(:second)" defp datetime_now(%{timestamp_type: :utc_datetime}), do: "DateTime.utc_now(:second)" defp datetime_now(%{timestamp_type: :utc_datetime_usec}), do: "DateTime.utc_now()" defp put_live_option(schema) do opts = case Keyword.fetch(schema.opts, :live) do {:ok, _live?} -> schema.opts _ -> Mix.shell().info(""" An authentication system can be created in two different ways: - Using Phoenix.LiveView (default) - Using Phoenix.Controller only\ """) if Mix.shell().yes?("Do you want to create a LiveView based authentication system?") do Keyword.put_new(schema.opts, :live, true) else Keyword.put_new(schema.opts, :live, false) end end Map.put(schema, :opts, opts) end end ================================================ FILE: lib/mix/tasks/phx.gen.cert.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Cert do @shortdoc "Generates a self-signed certificate for HTTPS testing" @default_path "priv/cert/selfsigned" @default_name "Self-signed test certificate" @default_hostnames ["localhost"] @warning """ WARNING: only use the generated certificate for testing in a closed network environment, such as running a development server on `localhost`. For production, staging, or testing servers on the public internet, obtain a proper certificate, for example from [Let's Encrypt](https://letsencrypt.org). """ @moduledoc """ Generates a self-signed certificate for HTTPS testing. $ mix phx.gen.cert $ mix phx.gen.cert my-app.localhost my-app.internal.example.com Creates a private key and a self-signed certificate in PEM format. These files can be referenced in the `certfile` and `keyfile` parameters of an HTTPS Endpoint. #{@warning} ## Arguments The list of hostnames, if none are specified, defaults to: * #{Enum.join(@default_hostnames, "\n * ")} Other (optional) arguments: * `--output` (`-o`): the path and base filename for the certificate and key (default: #{@default_path}) * `--name` (`-n`): the Common Name value in certificate's subject (default: "#{@default_name}") Requires OTP 21.3 or later. """ use Mix.Task import Mix.Generator @doc false def run(all_args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.cert must be invoked from within your *_web application root directory" ) end {opts, args} = OptionParser.parse!( all_args, aliases: [n: :name, o: :output], strict: [name: :string, output: :string] ) path = opts[:output] || @default_path name = opts[:name] || @default_name hostnames = case args do [] -> @default_hostnames list -> list end {certificate, private_key} = certificate_and_key(2048, name, hostnames) keyfile = path <> "_key.pem" certfile = path <> ".pem" create_file( keyfile, :public_key.pem_encode([:public_key.pem_entry_encode(:RSAPrivateKey, private_key)]) ) create_file( certfile, :public_key.pem_encode([{:Certificate, certificate, :not_encrypted}]) ) print_shell_instructions(keyfile, certfile) end @doc false def certificate_and_key(key_size, name, hostnames) do private_key = case generate_rsa_key(key_size, 65537) do {:ok, key} -> key {:error, :not_supported} -> Mix.raise(""" Failed to generate an RSA key pair. This Mix task requires Erlang/OTP 20 or later. Please upgrade to a newer version, or use another tool, such as OpenSSL, to generate a certificate. """) end public_key = extract_public_key(private_key) certificate = public_key |> new_cert(name, hostnames) |> :public_key.pkix_sign(private_key) {certificate, private_key} end defp print_shell_instructions(keyfile, certfile) do app = Mix.Phoenix.otp_app() base = Mix.Phoenix.base() Mix.shell().info(""" If you have not already done so, please update your HTTPS Endpoint configuration in config/dev.exs: config #{inspect(app)}, #{inspect(Mix.Phoenix.web_module(base))}.Endpoint, ..., https: [ # Change to `ip: {0, 0, 0, 0}` to allow access from other machines ip: {127, 0, 0, 1}, port: 4001, cipher_suite: :strong, certfile: "#{certfile}", keyfile: "#{keyfile}" ], ... #{@warning} """) end require Record # RSA key pairs Record.defrecordp( :rsa_private_key, :RSAPrivateKey, Record.extract(:RSAPrivateKey, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :rsa_public_key, :RSAPublicKey, Record.extract(:RSAPublicKey, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) defp generate_rsa_key(keysize, e) do private_key = :public_key.generate_key({:rsa, keysize, e}) {:ok, private_key} rescue FunctionClauseError -> {:error, :not_supported} end defp extract_public_key(rsa_private_key(modulus: m, publicExponent: e)) do rsa_public_key(modulus: m, publicExponent: e) end # Certificates Record.defrecordp( :otp_tbs_certificate, :OTPTBSCertificate, Record.extract(:OTPTBSCertificate, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :signature_algorithm, :SignatureAlgorithm, Record.extract(:SignatureAlgorithm, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :validity, :Validity, Record.extract(:Validity, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :otp_subject_public_key_info, :OTPSubjectPublicKeyInfo, Record.extract(:OTPSubjectPublicKeyInfo, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :public_key_algorithm, :PublicKeyAlgorithm, Record.extract(:PublicKeyAlgorithm, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :extension, :Extension, Record.extract(:Extension, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :basic_constraints, :BasicConstraints, Record.extract(:BasicConstraints, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) Record.defrecordp( :attr, :AttributeTypeAndValue, Record.extract(:AttributeTypeAndValue, from_lib: "public_key/include/OTP-PUB-KEY.hrl") ) # OID values @rsaEncryption {1, 2, 840, 113_549, 1, 1, 1} @sha256WithRSAEncryption {1, 2, 840, 113_549, 1, 1, 11} @basicConstraints {2, 5, 29, 19} @keyUsage {2, 5, 29, 15} @extendedKeyUsage {2, 5, 29, 37} @subjectKeyIdentifier {2, 5, 29, 14} @subjectAlternativeName {2, 5, 29, 17} @organizationName {2, 5, 4, 10} @commonName {2, 5, 4, 3} @serverAuth {1, 3, 6, 1, 5, 5, 7, 3, 1} @clientAuth {1, 3, 6, 1, 5, 5, 7, 3, 2} defp new_cert(public_key, common_name, hostnames) do <> = :crypto.strong_rand_bytes(8) today = Date.utc_today() not_before = today |> Date.to_iso8601(:basic) |> String.slice(2, 6) not_after = today |> Date.add(365) |> Date.to_iso8601(:basic) |> String.slice(2, 6) otp_tbs_certificate( version: :v3, serialNumber: serial, signature: signature_algorithm(algorithm: @sha256WithRSAEncryption), issuer: rdn(common_name), validity: validity( notBefore: {:utcTime, ~c"#{not_before}000000Z"}, notAfter: {:utcTime, ~c"#{not_after}000000Z"} ), subject: rdn(common_name), subjectPublicKeyInfo: otp_subject_public_key_info( algorithm: public_key_algorithm(algorithm: @rsaEncryption), subjectPublicKey: public_key ), extensions: extensions(public_key, hostnames) ) end defp rdn(common_name) do {:rdnSequence, [ [attr(type: @organizationName, value: {:utf8String, "Phoenix Framework"})], [attr(type: @commonName, value: {:utf8String, common_name})] ]} end defp extensions(public_key, hostnames) do [ extension( extnID: @basicConstraints, critical: true, extnValue: basic_constraints(cA: false) ), extension( extnID: @keyUsage, critical: true, extnValue: [:digitalSignature, :keyEncipherment] ), extension( extnID: @extendedKeyUsage, critical: false, extnValue: [@serverAuth, @clientAuth] ), extension( extnID: @subjectKeyIdentifier, critical: false, extnValue: key_identifier(public_key) ), extension( extnID: @subjectAlternativeName, critical: false, extnValue: Enum.map(hostnames, &{:dNSName, String.to_charlist(&1)}) ) ] end defp key_identifier(public_key) do :crypto.hash(:sha, :public_key.der_encode(:RSAPublicKey, public_key)) end end ================================================ FILE: lib/mix/tasks/phx.gen.channel.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Channel do @shortdoc "Generates a Phoenix channel" @moduledoc """ Generates a Phoenix channel. $ mix phx.gen.channel Room Accepts the module name for the channel The generated files will contain: For a regular application: * a channel in `lib/my_app_web/channels` * a channel test in `test/my_app_web/channels` For an umbrella application: * a channel in `apps/my_app_web/lib/app_name_web/channels` * a channel test in `apps/my_app_web/test/my_app_web/channels` """ use Mix.Task alias Mix.Tasks.Phx.Gen @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.channel must be invoked from within your *_web application root directory" ) end [channel_name] = validate_args!(args) context_app = Mix.Phoenix.context_app() web_prefix = Mix.Phoenix.web_path(context_app) web_test_prefix = Mix.Phoenix.web_test_path(context_app) binding = Mix.Phoenix.inflect(channel_name) binding = Keyword.put(binding, :module, "#{binding[:web_module]}.#{binding[:scoped]}") Mix.Phoenix.check_module_name_availability!(binding[:module] <> "Channel") test_path = Path.join(web_test_prefix, "channels/#{binding[:path]}_channel_test.exs") case_path = Path.join(Path.dirname(web_test_prefix), "support/channel_case.ex") maybe_case = if File.exists?(case_path) do [] else [{:eex, "channel_case.ex.eex", case_path}] end Mix.Phoenix.copy_from( paths(), "priv/templates/phx.gen.channel", binding, [ {:eex, "channel.ex.eex", Path.join(web_prefix, "channels/#{binding[:path]}_channel.ex")}, {:eex, "channel_test.exs.eex", test_path} ] ++ maybe_case ) user_socket_path = Mix.Phoenix.web_path(context_app, "channels/user_socket.ex") if File.exists?(user_socket_path) do Mix.shell().info(""" Add the channel to your `#{user_socket_path}` handler, for example: channel "#{binding[:singular]}:lobby", #{binding[:module]}Channel """) else Mix.shell().info(""" The default socket handler - #{binding[:web_module]}.UserSocket - was not found. """) if Mix.shell().yes?("Do you want to create it?") do Gen.Socket.run(~w(User --from-channel #{channel_name})) else Mix.shell().info(""" To create it, please run the mix task: mix phx.gen.socket User Then add the channel to the newly created file, at `#{user_socket_path}`: channel "#{binding[:singular]}:lobby", #{binding[:module]}Channel """) end end end @spec raise_with_help() :: no_return() defp raise_with_help do Mix.raise(""" mix phx.gen.channel expects just the module name, following capitalization: mix phx.gen.channel Room """) end defp validate_args!(args) do unless length(args) == 1 and args |> hd() |> valid_name?() do raise_with_help() end args end defp valid_name?(name) do name =~ ~r/^[A-Z]\w*(\.[A-Z]\w*)*$/ end defp paths do [".", :phoenix] end end ================================================ FILE: lib/mix/tasks/phx.gen.context.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Context do @shortdoc "Generates a context with functions around an Ecto schema" @moduledoc """ Generates a context with functions around an Ecto schema. ```console $ mix phx.gen.context Accounts User users name:string age:integer ``` The first argument is the context module followed by the schema module and its plural name (used as the schema table name). The context is an Elixir module that serves as an API boundary for the given resource. A context often holds many related resources. Therefore, if the context already exists, it will be augmented with functions for the given resource. > Note: A resource may also be split > over distinct contexts (such as Accounts.User and Payments.User). The schema is responsible for mapping the database fields into an Elixir struct. Overall, this generator will add the following files to `lib/your_app`: * a context module in `accounts.ex`, serving as the API boundary * a schema in `accounts/user.ex`, with a `users` table A migration file for the repository and test files for the context will also be generated. The generated migration can be skipped with `--no-migration`. ## Scopes If your application configures its own default [scope](scopes.md), then this generator will automatically make sure all of your context operations are correctly scoped. You can pass the `--no-scope` flag to disable the scoping. ## Generating without a schema In some cases, you may wish to bootstrap the context module and tests, but leave internal implementation of the context and schema to yourself. Use the `--no-schema` flags to accomplish this. ## `--table` By default, the table name for the migration and schema will be the plural name provided for the resource. To customize this value, a `--table` option may be provided. For example: $ mix phx.gen.context Accounts User users --table cms_users ## `--binary-id` Generated migration can use `binary_id` for schema's primary key and its references with option `--binary-id`. ## Default options This generator uses default options provided in the `:generators` configuration of your application. These are the defaults: config :your_app, :generators, migration: true, binary_id: false, timestamp_type: :naive_datetime, sample_binary_id: "11111111-1111-1111-1111-111111111111" You can override those options per invocation by providing corresponding switches, e.g. `--no-binary-id` to use normal ids despite the default configuration or `--migration` to force generation of the migration. Read the documentation for `phx.gen.schema` for more information on attributes. ## Skipping prompts This generator will prompt you if there is an existing context with the same name, in order to provide more instructions on how to correctly use phoenix contexts. You can skip this prompt and automatically merge the new schema access functions and tests into the existing context using `--merge-with-existing-context`. To prevent changes to the existing context and exit the generator, use `--no-merge-with-existing-context`. """ use Mix.Task alias Mix.Phoenix.{Context, Schema} alias Mix.Tasks.Phx.Gen @switches [ binary_id: :boolean, table: :string, web: :string, schema: :boolean, context: :boolean, context_app: :string, merge_with_existing_context: :boolean, prefix: :string, live: :boolean, compile: :boolean, primary_key: :string, migration: :boolean, scope: :string, no_scope: :boolean ] @default_opts [schema: true, context: true] @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.context must be invoked from within your *_web application root directory" ) end {context, schema} = build(args) binding = [ context: context, schema: schema, scope: context.scope, primary_key: schema.opts[:primary_key] || :id ] paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(context) prompt_for_code_injection(context) context |> copy_new_files(paths, binding) |> print_shell_instructions() end defp prompt_for_conflicts(context) do context |> files_to_be_generated() |> Mix.Phoenix.prompt_for_conflicts() end @doc false def build(args, opts \\ []) do help = Keyword.get(opts, :help_module, __MODULE__) optional = Keyword.get(opts, :name_optional, false) {opts, parsed, _} = parse_opts(args) {context_name, schema_name, plural, schema_args} = validate_args!(parsed, optional, help) schema_module = inspect(Module.concat(context_name, schema_name)) schema = Gen.Schema.build([schema_module, plural | schema_args], opts, help) context = Context.new(context_name, schema, opts) {context, schema} end defp parse_opts(args) do {opts, parsed, invalid} = OptionParser.parse(args, switches: @switches) merged_opts = @default_opts |> Keyword.merge(opts) |> put_context_app(opts[:context_app]) {merged_opts, parsed, invalid} end defp put_context_app(opts, nil), do: opts defp put_context_app(opts, string) do Keyword.put(opts, :context_app, String.to_atom(string)) end @doc false def files_to_be_generated(%Context{schema: schema}) do if schema.generate? do Gen.Schema.files_to_be_generated(schema) else [] end end @doc false def copy_new_files(%Context{schema: schema} = context, paths, binding) do if schema.generate?, do: Gen.Schema.copy_new_files(schema, paths, binding) inject_schema_access(context, paths, binding) inject_tests(context, paths, binding) inject_test_fixture(context, paths, binding) context end @doc false def ensure_context_file_exists(%Context{file: file} = context, paths, binding) do unless Context.pre_existing?(context) do Mix.Generator.create_file( file, Mix.Phoenix.eval_from(paths, "priv/templates/phx.gen.context/context.ex.eex", binding) ) end end defp inject_schema_access(%Context{file: file} = context, paths, binding) do ensure_context_file_exists(context, paths, binding) paths |> Mix.Phoenix.eval_from( "priv/templates/phx.gen.context/#{schema_access_template(context)}", binding ) |> inject_eex_before_final_end(file, binding) end defp write_file(content, file) do File.write!(file, content) end @doc false def ensure_test_file_exists(%Context{test_file: test_file} = context, paths, binding) do unless Context.pre_existing_tests?(context) do Mix.Generator.create_file( test_file, Mix.Phoenix.eval_from(paths, "priv/templates/phx.gen.context/context_test.exs.eex", binding) ) end end defp inject_tests(%Context{test_file: test_file} = context, paths, binding) do ensure_test_file_exists(context, paths, binding) file = if context.schema.scope do "test_cases_scope.exs.eex" else "test_cases.exs.eex" end paths |> Mix.Phoenix.eval_from("priv/templates/phx.gen.context/#{file}", binding) |> inject_eex_before_final_end(test_file, binding) end @doc false def ensure_test_fixtures_file_exists( %Context{test_fixtures_file: test_fixtures_file} = context, paths, binding ) do unless Context.pre_existing_test_fixtures?(context) do Mix.Generator.create_file( test_fixtures_file, Mix.Phoenix.eval_from(paths, "priv/templates/phx.gen.context/fixtures_module.ex.eex", binding) ) end end defp inject_test_fixture( %Context{test_fixtures_file: test_fixtures_file} = context, paths, binding ) do ensure_test_fixtures_file_exists(context, paths, binding) paths |> Mix.Phoenix.eval_from("priv/templates/phx.gen.context/fixtures.ex.eex", binding) |> Mix.Phoenix.prepend_newline() |> inject_eex_before_final_end(test_fixtures_file, binding) maybe_print_unimplemented_fixture_functions(context) end defp maybe_print_unimplemented_fixture_functions(%Context{} = context) do fixture_functions_needing_implementations = Enum.flat_map( context.schema.fixture_unique_functions, fn {_field, {_function_name, function_def, true}} -> [function_def] {_field, {_function_name, _function_def, false}} -> [] end ) if Enum.any?(fixture_functions_needing_implementations) do Mix.shell().info(""" Some of the generated database columns are unique. Please provide unique implementations for the following fixture function(s) in #{context.test_fixtures_file}: #{fixture_functions_needing_implementations |> Enum.map_join(&indent(&1, 2)) |> String.trim_trailing()} """) end end defp indent(string, spaces) do indent_string = String.duplicate(" ", spaces) string |> String.split("\n") |> Enum.map_join(fn line -> if String.trim(line) == "" do "\n" else indent_string <> line <> "\n" end end) end defp inject_eex_before_final_end(content_to_inject, file_path, binding) do file = File.read!(file_path) if String.contains?(file, content_to_inject) do :ok else Mix.shell().info([:green, "* injecting ", :reset, Path.relative_to_cwd(file_path)]) file |> String.trim_trailing() |> String.trim_trailing("end") |> EEx.eval_string(binding) |> Kernel.<>(content_to_inject) |> Kernel.<>("end\n") |> write_file(file_path) end end @doc false def print_shell_instructions(%Context{schema: schema}) do if schema.generate? do Gen.Schema.print_shell_instructions(schema) else :ok end end defp schema_access_template(%Context{schema: schema}) do cond do schema.generate? && schema.scope -> "schema_access_scope.ex.eex" schema.generate? -> "schema_access.ex.eex" schema.scope -> "access_no_schema_scope.ex.eex" true -> "access_no_schema.ex.eex" end end defp validate_args!( [maybe_context_name, schema_name_or_plural, plural_or_first_attr | schema_args], optional, help ) do has_context? = case schema_name_or_plural do <> when char in ?A..?Z -> true _ -> not optional end {context, schema, plural, schema_args} = if has_context? do {maybe_context_name, schema_name_or_plural, plural_or_first_attr, schema_args} else # mix phx.gen.live User users name:string # we generate the context from the plural "users" -> Users context = Phoenix.Naming.camelize(schema_name_or_plural) if context == maybe_context_name do # if someone did # mix phx.gen.live Users users name Mix.raise(""" The given schema #{maybe_context_name} is equal to the camelized version of the table plural #{schema_name_or_plural}, but the schema is expected to be singular. Please pass an explicit context option like: mix phx.gen.live #{context} #{maybe_context_name} #{schema_name_or_plural} if this is what you want. """) end {context, maybe_context_name, schema_name_or_plural, [plural_or_first_attr | schema_args]} end cond do not Context.valid?(context) -> help.raise_with_help( "Expected the context, #{inspect(context)}, to be a valid module name" ) not Schema.valid?(schema) -> help.raise_with_help("Expected the schema, #{inspect(schema)}, to be a valid module name") context == schema -> help.raise_with_help("The context and schema should have different names") context == Mix.Phoenix.base() -> help.raise_with_help( "Cannot generate context #{context} because it has the same name as the application" ) schema == Mix.Phoenix.base() -> help.raise_with_help( "Cannot generate schema #{schema} because it has the same name as the application" ) true -> {context, schema, plural, schema_args} end end defp validate_args!(_, _, help) do help.raise_with_help("Invalid arguments") end @doc false def raise_with_help(msg) do Mix.raise(""" #{msg} mix phx.gen.html, phx.gen.json, phx.gen.live, and phx.gen.context expect a context module name, followed by singular and plural names of the generated resource, ending with any number of attributes. For example: mix phx.gen.html [Accounts] User users name:string mix phx.gen.json [Accounts] User users name:string mix phx.gen.live [Accounts] User users name:string mix phx.gen.context Accounts User users name:string The context serves as the API boundary for the given resource. It is optional except for phx.gen.context. Multiple resources may belong to a context and a resource may be split over distinct contexts (such as Accounts.User and Payments.User). """) end @doc false def prompt_for_code_injection(%Context{generate?: false}), do: :ok def prompt_for_code_injection(%Context{} = context) do if Context.pre_existing?(context) && !merge_with_existing_context?(context) do System.halt() end end defp merge_with_existing_context?(%Context{} = context) do Keyword.get_lazy(context.opts, :merge_with_existing_context, fn -> function_count = Context.function_count(context) file_count = Context.file_count(context) Mix.shell().info(""" You are generating into an existing context. The #{inspect(context.module)} context currently has #{singularize(function_count, "functions")} and \ #{singularize(file_count, "files")} in its directory. * It's OK to have multiple resources in the same context as \ long as they are closely related. But if a context grows too \ large, consider breaking it apart * If they are not closely related, another context probably works better The fact that two entities are related in the database does not mean they belong \ to the same context. If you are not sure, prefer creating a new context over adding to the existing one. """) Mix.shell().yes?("Would you like to proceed?") end) end defp singularize(1, plural), do: "1 " <> String.trim_trailing(plural, "s") defp singularize(amount, plural), do: "#{amount} #{plural}" end ================================================ FILE: lib/mix/tasks/phx.gen.embedded.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Embedded do @shortdoc "Generates an embedded Ecto schema file" @moduledoc """ Generates an embedded Ecto schema for casting/validating data outside the DB. ```console $ mix phx.gen.embedded Blog.Post title:string views:integer ``` The first argument is the schema module followed by the schema attributes. The generated schema above will contain: * an embedded schema file in `lib/my_app/blog/post.ex` ## Attributes The resource fields are given using `name:type` syntax where type are the types supported by Ecto. Omitting the type makes it default to `:string`: ```console $ mix phx.gen.embedded Blog.Post title views:integer ``` The following types are supported: #{for attr <- Mix.Phoenix.Schema.valid_types(), do: " * `#{inspect attr}`\n"} * `:datetime` - An alias for `:naive_datetime` """ use Mix.Task alias Mix.Phoenix.Schema @switches [binary_id: :boolean, web: :string] @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise "mix phx.gen.embedded must be invoked from within your *_web application root directory" end schema = build(args) paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(schema) copy_new_files(schema, paths, schema: schema) end @doc false def build(args) do {schema_opts, parsed, _} = OptionParser.parse(args, switches: @switches) [schema_name | attrs] = validate_args!(parsed) opts = schema_opts |> Keyword.put(:embedded, true) |> Keyword.put(:migration, false) schema = Schema.new(schema_name, nil, attrs, opts) schema end @doc false def validate_args!([schema | _] = args) do if Schema.valid?(schema) do args else raise_with_help "Expected the schema argument, #{inspect schema}, to be a valid module name" end end def validate_args!(_) do raise_with_help "Invalid arguments" end @doc false @spec raise_with_help(String.t) :: no_return() def raise_with_help(msg) do Mix.raise """ #{msg} mix phx.gen.embedded expects a module name followed by any number of attributes: mix phx.gen.embedded Blog.Post title:string """ end defp prompt_for_conflicts(schema) do schema |> files_to_be_generated() |> Mix.Phoenix.prompt_for_conflicts() end @doc false def files_to_be_generated(%Schema{} = schema) do [{:eex, "embedded_schema.ex.eex", schema.file}] end @doc false def copy_new_files(%Schema{} = schema, paths, binding) do files = files_to_be_generated(schema) Mix.Phoenix.copy_from(paths, "priv/templates/phx.gen.embedded", binding, files) schema end end ================================================ FILE: lib/mix/tasks/phx.gen.ex ================================================ defmodule Mix.Tasks.Phx.Gen do use Mix.Task @shortdoc "Lists all available Phoenix generators" @moduledoc """ Lists all available Phoenix generators. ## CRUD related generators The table below shows a summary of the contents created by the CRUD generators: | Task | Schema | Migration | Context | Controller | View | LiveView | |:------------------ |:-:|:-:|:-:|:-:|:-:|:-:| | `phx.gen.embedded` | x | | | | | | | `phx.gen.schema` | x | x | | | | | | `phx.gen.context` | x | x | x | | | | | `phx.gen.live` | x | x | x | | | x | | `phx.gen.json` | x | x | x | x | x | | | `phx.gen.html` | x | x | x | x | x | | ## Customizing generators You can override the default templates used by generators. For example, to customize `phx.gen.live`, you can copy and edit the generator templates to your own project's priv folder: First, create the directory for your custom `phx.gen.live` templates: ```console $ mkdir -p priv/templates/phx.gen.live ``` Next, copy the default phx.gen.live generator templates into your project so you can customize them: ```console $ cp -r deps/phoenix/priv/templates/phx.gen.live/* priv/templates/phx.gen.live/ ``` Phoenix generators will look for templates in your project's `priv/templates` directory first. If a matching template is found, it will be used instead of the default. Note generator templates may change between minor or even patch Phoenix releases, so custom templates may require updates after upgrading. Use this mechanism at your own risk. """ def run(_args) do Mix.Task.run("help", ["--search", "phx.gen."]) end end ================================================ FILE: lib/mix/tasks/phx.gen.html.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Html do @shortdoc "Generates context and controller for an HTML resource" @moduledoc """ Generates controller with view, templates, schema and context for an HTML resource. The format is: ```console $ mix phx.gen.html [] [...] ``` For example: ```console $ mix phx.gen.html User users name:string age:integer ``` Will generate a `User` schema for the `users` table within the `Users` context, with the attributes `name` (as a string) and `age` (as an integer). You can also explicitly pass the context name as argument, whenever the context is well defined: ```console $ mix phx.gen.html Accounts User users name:string age:integer ``` The first argument is the context module (`Accounts`) followed by the schema module (`User`), table name (`users`), and attributes. The context is an Elixir module that serves as an API boundary for the given resource. A context often holds many related resources. Therefore, if the context already exists, it will be augmented with functions for the given resource. The schema is responsible for mapping the database fields into an Elixir struct. It is followed by a list of attributes with their respective names and types. See `mix phx.gen.schema` for more information on attributes. Overall, this generator will add the following files to `lib/`: * a controller in `lib/my_app_web/controllers/user_controller.ex` * default CRUD HTML templates in `lib/my_app_web/controllers/user_html` * an HTML view collocated with the controller in `lib/my_app_web/controllers/user_html.ex` * a schema in `lib/my_app/accounts/user.ex`, with an `users` table * a context module in `lib/my_app/accounts.ex` for the accounts API Additionally, this generator creates the following files: * a migration for the schema in `priv/repo/migrations` * a controller test module in `test/my_app/controllers/user_controller_test.exs` * a context test module in `test/my_app/accounts_test.exs` * a context test helper module in `test/support/fixtures/accounts_fixtures.ex` If the context already exists, this generator injects functions for the given resource into the context, context test, and context test helper modules. ## Scopes If your application configures its own default [scope](scopes.md), then this generator will automatically make sure all of your context operations are correctly scoped. You can pass the `--no-scope` flag to disable the scoping. ## Umbrella app configuration By default, Phoenix injects both web and domain specific functionality into the same application. When using umbrella applications, those concerns are typically broken into two separate apps, your context application - let's call it `my_app` - and its web layer, which Phoenix assumes to be `my_app_web`. You can teach Phoenix to use this style via the `:context_app` configuration option in your `my_app_umbrella/config/config.exs`: config :my_app_web, ecto_repos: [Stuff.Repo], generators: [context_app: :my_app] Alternatively, the `--context-app` option may be supplied to the generator: ```console $ mix phx.gen.html Accounts User users --context-app my_app ``` ## Web namespace By default, the controller and HTML views are not namespaced but you can add a namespace by passing the `--web` flag with a module name, for example: ```console $ mix phx.gen.html Accounts User users --web Accounts ``` Which would generate a `lib/app_web/controllers/accounts/user_controller.ex` and `lib/app_web/controllers/accounts/user_html.ex`. ## Customizing the context, schema, tables and migrations In some cases, you may wish to bootstrap HTML templates, controllers, and controller tests, but leave internal implementation of the context or schema to yourself. You can use the `--no-context` and `--no-schema` flags for file generation control. Note `--no-context` implies `--no-schema`: ```console $ mix phx.gen.live Accounts User users --no-context name:string ``` In the cases above, tests are still generated, but they will all fail. You can also change the table name or configure the migrations to use binary ids for primary keys, see `mix phx.gen.schema` for more information. """ use Mix.Task alias Mix.Phoenix.{Context, Schema, Scope} alias Mix.Tasks.Phx.Gen @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.html must be invoked from within your *_web application root directory" ) end Mix.Phoenix.ensure_live_view_compat!(__MODULE__) {context, schema} = Gen.Context.build(args, name_optional: true) if schema.attrs == [] do Mix.raise(""" No attributes provided. The phx.gen.html generator requires at least one attribute. For example: mix phx.gen.html Accounts User users name:string """) end Gen.Context.prompt_for_code_injection(context) {conn_scope, context_scope_prefix} = if schema.scope do base = "conn.assigns.#{schema.scope.assign_key}" {base, "#{base}, "} else {"", ""} end binding = [ context: context, schema: schema, primary_key: schema.opts[:primary_key] || :id, scope: schema.scope, inputs: inputs(schema), conn_scope: conn_scope, context_scope_prefix: context_scope_prefix, scope_conn_route_prefix: Scope.route_prefix(conn_scope, schema), scope_param_route_prefix: Scope.route_prefix("scope", schema), scope_assign_route_prefix: scope_assign_route_prefix(schema), test_context_scope: if(schema.scope && schema.scope.route_prefix, do: ", scope: scope", else: "") ] paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(context) context |> copy_new_files(paths, binding) |> print_shell_instructions() end defp prompt_for_conflicts(context) do context |> files_to_be_generated() |> Kernel.++(context_files(context)) |> Mix.Phoenix.prompt_for_conflicts() end defp context_files(%Context{generate?: true} = context) do Gen.Context.files_to_be_generated(context) end defp context_files(%Context{generate?: false}) do [] end @doc false def files_to_be_generated(%Context{schema: schema, context_app: context_app}) do singular = schema.singular web_prefix = Mix.Phoenix.web_path(context_app) test_prefix = Mix.Phoenix.web_test_path(context_app) web_path = to_string(schema.web_path) controller_pre = Path.join([web_prefix, "controllers", web_path]) test_pre = Path.join([test_prefix, "controllers", web_path]) [ {:eex, "controller.ex.eex", Path.join([controller_pre, "#{singular}_controller.ex"])}, {:eex, "edit.html.heex.eex", Path.join([controller_pre, "#{singular}_html", "edit.html.heex"])}, {:eex, "index.html.heex.eex", Path.join([controller_pre, "#{singular}_html", "index.html.heex"])}, {:eex, "new.html.heex.eex", Path.join([controller_pre, "#{singular}_html", "new.html.heex"])}, {:eex, "show.html.heex.eex", Path.join([controller_pre, "#{singular}_html", "show.html.heex"])}, {:eex, "resource_form.html.heex.eex", Path.join([controller_pre, "#{singular}_html", "#{singular}_form.html.heex"])}, {:eex, "html.ex.eex", Path.join([controller_pre, "#{singular}_html.ex"])}, {:eex, "controller_test.exs.eex", Path.join([test_pre, "#{singular}_controller_test.exs"])} ] end @doc false def copy_new_files(%Context{} = context, paths, binding) do files = files_to_be_generated(context) Mix.Phoenix.copy_from(paths, "priv/templates/phx.gen.html", binding, files) if context.generate?, do: Gen.Context.copy_new_files(context, paths, binding) context end @doc false def print_shell_instructions(%Context{schema: schema, context_app: ctx_app} = context) do resource_path = if schema.scope && schema.scope.route_prefix do "#{schema.scope.route_prefix}/#{schema.plural}" else "/#{schema.plural}" end if schema.web_namespace do Mix.shell().info(""" Add the resource to your #{schema.web_namespace} :browser scope in #{Mix.Phoenix.web_path(ctx_app)}/router.ex: scope "/#{schema.web_path}", #{inspect(Module.concat(context.web_module, schema.web_namespace))} do pipe_through :browser ... resources "#{resource_path}", #{inspect(schema.alias)}Controller#{if schema.opts[:primary_key], do: ~s[, param: "#{schema.opts[:primary_key]}"]} end """) else Mix.shell().info(""" Add the resource to your browser scope in #{Mix.Phoenix.web_path(ctx_app)}/router.ex: resources "#{resource_path}", #{inspect(schema.alias)}Controller#{if schema.opts[:primary_key], do: ~s[, param: "#{schema.opts[:primary_key]}"]} """) end if schema.scope do Mix.shell().info( "Ensure the routes are defined in a block that sets the `#{inspect(context.scope.assign_key)}` assign." ) end if context.generate?, do: Gen.Context.print_shell_instructions(context) end @doc false def inputs(%Schema{} = schema) do schema.attrs |> Enum.reject(fn {_key, type} -> type == :map end) |> Enum.map(fn {key, :integer} -> ~s(<.input field={f[#{inspect(key)}]} type="number" label="#{label(key)}" />) {key, :float} -> ~s(<.input field={f[#{inspect(key)}]} type="number" label="#{label(key)}" step="any" />) {key, :decimal} -> ~s(<.input field={f[#{inspect(key)}]} type="number" label="#{label(key)}" step="any" />) {key, :boolean} -> ~s(<.input field={f[#{inspect(key)}]} type="checkbox" label="#{label(key)}" />) {key, :text} -> ~s(<.input field={f[#{inspect(key)}]} type="textarea" label="#{label(key)}" />) {key, :date} -> ~s(<.input field={f[#{inspect(key)}]} type="date" label="#{label(key)}" />) {key, :time} -> ~s(<.input field={f[#{inspect(key)}]} type="time" label="#{label(key)}" />) {key, :utc_datetime} -> ~s(<.input field={f[#{inspect(key)}]} type="datetime-local" label="#{label(key)}" />) {key, :naive_datetime} -> ~s(<.input field={f[#{inspect(key)}]} type="datetime-local" label="#{label(key)}" />) {key, {:array, _} = type} -> ~s""" <.input field={f[#{inspect(key)}]} type="select" multiple label="#{label(key)}" options={#{inspect(default_options(type))}} /> """ {key, {:enum, _}} -> ~s""" <.input field={f[#{inspect(key)}]} type="select" label="#{label(key)}" prompt="Choose a value" options={Ecto.Enum.values(#{inspect(schema.module)}, #{inspect(key)})} /> """ {key, _} -> ~s(<.input field={f[#{inspect(key)}]} type="text" label="#{label(key)}" />) end) end defp default_options({:array, :string}), do: Enum.map([1, 2], &{"Option #{&1}", "option#{&1}"}) defp default_options({:array, :integer}), do: Enum.map([1, 2], &{"#{&1}", &1}) defp default_options({:array, _}), do: [] defp label(key), do: Phoenix.Naming.humanize(to_string(key)) defp scope_assign_route_prefix( %{scope: %{route_prefix: route_prefix, assign_key: assign_key}} = schema ) when not is_nil(route_prefix) do Scope.route_prefix("@#{assign_key}", schema) end defp scope_assign_route_prefix(_), do: "" @doc false def indent_inputs(inputs, column_padding) do columns = String.duplicate(" ", column_padding) inputs |> Enum.map(fn input -> lines = input |> String.split("\n") |> Enum.reject(&(&1 == "")) case lines do [] -> [] [line] -> [columns, line] [first_line | rest] -> rest = Enum.map_join(rest, "\n", &(columns <> &1)) [columns, first_line, "\n", rest] end end) |> Enum.intersperse("\n") end end ================================================ FILE: lib/mix/tasks/phx.gen.json.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Json do @shortdoc "Generates context and controller for a JSON resource" @moduledoc """ Generates controller, JSON view, and context for a JSON resource. The format is: ```console $ mix phx.gen.json []
[...] ``` For example: ```console $ mix phx.gen.json User users name:string age:integer ``` Will generate a `User` schema for the `users` table within the `Users` context, with the attributes `name` (as a string) and `age` (as an integer). You can also explicitly pass the context name as argument, whenever the context is well defined: ```console $ mix phx.gen.json Accounts User users name:string age:integer ``` The first argument is the context module (`Accounts`) followed by the schema module (`User`), table name (`users`), and attributes. The context is an Elixir module that serves as an API boundary for the given resource. A context often holds many related resources. Therefore, if the context already exists, it will be augmented with functions for the given resource. The schema is responsible for mapping the database fields into an Elixir struct. It is followed by a list of attributes with their respective names and types. See `mix phx.gen.schema` for more information on attributes. Overall, this generator will add the following files to `lib/`: * a context module in `lib/app/accounts.ex` for the accounts API * a schema in `lib/app/accounts/user.ex`, with an `users` table * a controller in `lib/app_web/controllers/user_controller.ex` * a JSON view collocated with the controller in `lib/app_web/controllers/user_json.ex` A migration file for the repository and test files for the context and controller features will also be generated. ## API Prefix By default, the prefix "/api" will be generated for API route paths. This can be customized via the `:api_prefix` generators configuration: config :your_app, :generators, api_prefix: "/api/v1" ## Scopes If your application configures its own default [scope](scopes.md), then this generator will automatically make sure all of your context operations are correctly scoped. You can pass the `--no-scope` flag to disable the scoping. ## Umbrella app configuration By default, Phoenix injects both web and domain specific functionality into the same application. When using umbrella applications, those concerns are typically broken into two separate apps, your context application - let's call it `my_app` - and its web layer, which Phoenix assumes to be `my_app_web`. You can teach Phoenix to use this style via the `:context_app` configuration option in your `my_app_umbrella/config/config.exs`: config :my_app_web, ecto_repos: [Stuff.Repo], generators: [context_app: :my_app] Alternatively, the `--context-app` option may be supplied to the generator: ```console $ mix phx.gen.html Accounts User users --context-app my_app ``` ## Web namespace By default, the controller and HTML views are not namespaced but you can add a namespace by passing the `--web` flag with a module name, for example: ```console $ mix phx.gen.json Accounts User users --web Accounts ``` Which would generate a `lib/app_web/controllers/accounts/user_controller.ex` and `lib/app_web/controllers/accounts/user_json.ex`. ## Customizing the context, schema, tables and migrations In some cases, you may wish to bootstrap JSON views, controllers, and controller tests, but leave internal implementation of the context or schema to yourself. You can use the `--no-context` and `--no-schema` flags for file generation control. Note `--no-context` implies `--no-schema`: ```console $ mix phx.gen.live Accounts User users --no-context name:string ``` In the cases above, tests are still generated, but they will all fail. You can also change the table name or configure the migrations to use binary ids for primary keys, see `mix phx.gen.schema` for more information. """ use Mix.Task alias Mix.Phoenix.{Context, Scope} alias Mix.Tasks.Phx.Gen @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.json must be invoked from within your *_web application root directory" ) end {context, schema} = Gen.Context.build(args, name_optional: true) if schema.attrs == [] do Mix.raise(""" No attributes provided. The phx.gen.json generator requires at least one attribute. For example: mix phx.gen.json Accounts User users name:string """) end Gen.Context.prompt_for_code_injection(context) {conn_scope, context_scope_prefix} = if schema.scope do base = "conn.assigns.#{schema.scope.assign_key}" {base, "#{base}, "} else {"", ""} end binding = [ context: context, schema: schema, scope: schema.scope, core_components?: Code.ensure_loaded?(Module.concat(context.web_module, "CoreComponents")), gettext?: Code.ensure_loaded?(Module.concat(context.web_module, "Gettext")), primary_key: schema.opts[:primary_key] || :id, conn_scope: conn_scope, context_scope_prefix: context_scope_prefix, scope_conn_route_prefix: Scope.route_prefix(conn_scope, schema), scope_param_route_prefix: Scope.route_prefix("scope", schema), test_context_scope: if(schema.scope && schema.scope.route_prefix, do: ", scope: scope", else: "") ] paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(context) context |> copy_new_files(paths, binding) |> print_shell_instructions() end defp prompt_for_conflicts(context) do context |> files_to_be_generated() |> Kernel.++(context_files(context)) |> Mix.Phoenix.prompt_for_conflicts() end defp context_files(%Context{generate?: true} = context) do Gen.Context.files_to_be_generated(context) end defp context_files(%Context{generate?: false}) do [] end @doc false def files_to_be_generated(%Context{schema: schema, context_app: context_app}) do singular = schema.singular web = Mix.Phoenix.web_path(context_app) test_prefix = Mix.Phoenix.web_test_path(context_app) web_path = to_string(schema.web_path) controller_pre = Path.join([web, "controllers", web_path]) test_pre = Path.join([test_prefix, "controllers", web_path]) [ {:eex, "controller.ex.eex", Path.join([controller_pre, "#{singular}_controller.ex"])}, {:eex, "json.ex.eex", Path.join([controller_pre, "#{singular}_json.ex"])}, {:new_eex, "changeset_json.ex.eex", Path.join([web, "controllers/changeset_json.ex"])}, {:eex, "controller_test.exs.eex", Path.join([test_pre, "#{singular}_controller_test.exs"])}, {:new_eex, "fallback_controller.ex.eex", Path.join([web, "controllers/fallback_controller.ex"])} ] end @doc false def copy_new_files(%Context{} = context, paths, binding) do files = files_to_be_generated(context) Mix.Phoenix.copy_from(paths, "priv/templates/phx.gen.json", binding, files) if context.generate?, do: Gen.Context.copy_new_files(context, paths, binding) context end @doc false def print_shell_instructions(%Context{schema: schema, context_app: ctx_app} = context) do resource_path = if schema.scope && schema.scope.route_prefix do "#{schema.scope.route_prefix}/#{schema.plural}" else "/#{schema.plural}" end if schema.web_namespace do Mix.shell().info(""" Add the resource to your #{schema.web_namespace} :api scope in #{Mix.Phoenix.web_path(ctx_app)}/router.ex: scope "/#{schema.web_path}", #{inspect(Module.concat(context.web_module, schema.web_namespace))} do pipe_through :api ... resources "#{resource_path}", #{inspect(schema.alias)}Controller#{if schema.opts[:primary_key], do: ~s[, param: "#{schema.opts[:primary_key]}"]} end """) else Mix.shell().info(""" Add the resource to the "#{Application.get_env(ctx_app, :generators)[:api_prefix] || "/api"}" scope in #{Mix.Phoenix.web_path(ctx_app)}/router.ex: resources "#{resource_path}", #{inspect(schema.alias)}Controller, except: [:new, :edit]#{if schema.opts[:primary_key], do: ~s[, param: "#{schema.opts[:primary_key]}"]} """) end if schema.scope do Mix.shell().info( "Ensure the routes are defined in a block that sets the `#{inspect(context.scope.assign_key)}` assign." ) end if context.generate?, do: Gen.Context.print_shell_instructions(context) end end ================================================ FILE: lib/mix/tasks/phx.gen.live.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Live do @shortdoc "Generates LiveView, templates, and context for a resource" @moduledoc """ Generates LiveView, templates, and context for a resource. The format is: ```console $ mix phx.gen.live []
[...] ``` For example: ```console $ mix phx.gen.live User users name:string age:integer ``` Will generate a `User` schema for the `users` table within the `Users` context, with the attributes `name` (as a string) and `age` (as an integer). You can also explicitly pass the context name as argument, whenever the context is well defined: ```console $ mix phx.gen.live Accounts User users name:string age:integer ``` The first argument is the context module (`Accounts`) followed by the schema module (`User`), table name (`users`), and attributes. The context is an Elixir module that serves as an API boundary for the given resource. A context often holds many related resources. Therefore, if the context already exists, it will be augmented with functions for the given resource. The schema is responsible for mapping the database fields into an Elixir struct. It is followed by a list of attributes with their respective names and types. See `mix phx.gen.schema` for more information on attributes. Overall, this generator will add the following files to `lib/`: * a context module in `lib/app/accounts.ex` for the accounts API * a schema in `lib/app/accounts/user.ex`, with a `users` table * a LiveView in `lib/app_web/live/user_live/show.ex` * a LiveView in `lib/app_web/live/user_live/index.ex` * a LiveView in `lib/app_web/live/user_live/form.ex` * a components module in `lib/app_web/components/core_components.ex` if none exists After file generation is complete, there will be output regarding required updates to the `lib/app_web/router.ex` file. Add the live routes to your browser scope in lib/app_web/router.ex: live "/users", UserLive.Index, :index live "/users/new", UserLive.Form, :new live "/users/:id", UserLive.Show, :show live "/users/:id/edit", UserLive.Form, :edit ## Scopes If your application configures its own default [scope](scopes.md), then this generator will automatically make sure all of your context operations are correctly scoped. You can pass the `--no-scope` flag to disable the scoping. ## Umbrella app configuration By default, Phoenix injects both web and domain specific functionality into the same application. When using umbrella applications, those concerns are typically broken into two separate apps, your context application - let's call it `my_app` - and its web layer, which Phoenix assumes to be `my_app_web`. You can teach Phoenix to use this style via the `:context_app` configuration option in your `my_app_umbrella/config/config.exs`: config :my_app_web, ecto_repos: [Stuff.Repo], generators: [context_app: :my_app] Alternatively, the `--context-app` option may be supplied to the generator: ```console $ mix phx.gen.html Accounts User users --context-app my_app ``` ## Web namespace By default, the LiveView modules are defined within a folder named after the schema, such as `lib/app_web/live/user_live`. You can add additional namespaces by passing the `--web` flag with a module name, for example: ```console $ mix phx.gen.live Accounts User users --web Accounts name:string ``` Which would generate the LiveViews in `lib/app_web/live/accounts/user_live/`, namespaced `AppWeb.Accounts.UserLive` instead of `AppWeb.UserLive`. ## Customizing the context, schema, tables and migrations In some cases, you may wish to bootstrap HTML templates, LiveViews, and tests, but leave internal implementation of the context or schema to yourself. You can use the `--no-context` and `--no-schema` flags flags for file generation control. Note `--no-context` implies `--no-schema`: ```console $ mix phx.gen.live Accounts User users --no-context name:string ``` In the cases above, tests are still generated, but they will all fail. You can also change the table name or configure the migrations to use binary ids for primary keys, see `mix help phx.gen.schema` for more information. """ use Mix.Task alias Mix.Phoenix.{Context, Schema, Scope} alias Mix.Tasks.Phx.Gen @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.live must be invoked from within your *_web application root directory" ) end Mix.Phoenix.ensure_live_view_compat!(__MODULE__) {context, schema} = Gen.Context.build(args, name_optional: true) validate_context!(context) if schema.attrs == [] do Mix.raise(""" No attributes provided. The phx.gen.live generator requires at least one attribute. For example: mix phx.gen.live Accounts User users name:string """) end Gen.Context.prompt_for_code_injection(context) {socket_scope, context_scope_prefix, assign_scope, assign_scope_prefix} = if schema.scope do base_socket = "socket.assigns.#{schema.scope.assign_key}" base_assign = "@#{schema.scope.assign_key}" {base_socket, "#{base_socket}, ", base_assign, "#{base_assign}, "} else {"", "", "", ""} end binding = [ context: context, schema: schema, primary_key: schema.opts[:primary_key] || :id, scope: schema.scope, inputs: inputs(schema), socket_scope: socket_scope, context_scope_prefix: context_scope_prefix, assign_scope: assign_scope, assign_scope_prefix: assign_scope_prefix, scope_param_route_prefix: Scope.route_prefix("scope", schema), scope_param: scope_param(schema), scope_param_prefix: scope_param_prefix(schema), scope_socket_route_prefix: Scope.route_prefix(socket_scope, schema), scope_assign_route_prefix: scope_assign_route_prefix(schema), test_context_scope: if(schema.scope && schema.scope.route_prefix, do: ", scope: scope", else: "") ] paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(context) context |> copy_new_files(binding, paths) |> maybe_inject_imports() |> print_shell_instructions() end defp validate_context!(context) do cond do context.schema.singular == "form" -> Gen.Context.raise_with_help( "cannot use form as the schema name because it conflicts with the LiveView assigns!" ) true -> :ok end end defp prompt_for_conflicts(context) do context |> files_to_be_generated() |> Kernel.++(context_files(context)) |> Mix.Phoenix.prompt_for_conflicts() end defp context_files(%Context{generate?: true} = context) do Gen.Context.files_to_be_generated(context) end defp context_files(%Context{generate?: false}) do [] end defp files_to_be_generated(%Context{schema: schema, context_app: context_app}) do web_prefix = Mix.Phoenix.web_path(context_app) test_prefix = Mix.Phoenix.web_test_path(context_app) web_path = to_string(schema.web_path) live_subdir = "#{schema.singular}_live" web_live = Path.join([web_prefix, "live", web_path, live_subdir]) test_live = Path.join([test_prefix, "live", web_path]) [ {:eex, "show.ex.eex", Path.join(web_live, "show.ex")}, {:eex, "index.ex.eex", Path.join(web_live, "index.ex")}, {:eex, "form.ex.eex", Path.join(web_live, "form.ex")}, {:eex, "live_test.exs.eex", Path.join(test_live, "#{schema.singular}_live_test.exs")}, {:new_eex, "core_components.ex.eex", Path.join([web_prefix, "components", "core_components.ex"])} ] end defp copy_new_files(%Context{} = context, binding, paths) do files = files_to_be_generated(context) binding = Keyword.merge(binding, assigns: %{ web_namespace: inspect(context.web_module), gettext: true, live: true, # the core components are also generated in phx.new, so we check for # esbuild (@javascript) - here we just assume that it's there javascript: true } ) Mix.Phoenix.copy_from(paths, "priv/templates/phx.gen.live", binding, files) if context.generate?, do: Gen.Context.copy_new_files(context, paths, binding) context end defp maybe_inject_imports(%Context{context_app: ctx_app} = context) do web_prefix = Mix.Phoenix.web_path(ctx_app) [lib_prefix, web_dir] = Path.split(web_prefix) file_path = Path.join(lib_prefix, "#{web_dir}.ex") file = File.read!(file_path) inject = "import #{inspect(context.web_module)}.CoreComponents" if String.contains?(file, inject) do :ok else do_inject_imports(context, file, file_path, inject) end context end defp do_inject_imports(context, file, file_path, inject) do Mix.shell().info([:green, "* injecting ", :reset, Path.relative_to_cwd(file_path)]) new_file = String.replace( file, "use Phoenix.Component", "use Phoenix.Component\n #{inject}" ) if file != new_file do File.write!(file_path, new_file) else Mix.shell().info(""" Could not find use Phoenix.Component in #{file_path}. This typically happens because your application was not generated with the --live flag: mix phx.new my_app --live Please make sure LiveView is installed and that #{inspect(context.web_module)} defines both `live_view/0` and `live_component/0` functions, and that both functions import #{inspect(context.web_module)}.CoreComponents. """) end end @doc false def print_shell_instructions(%Context{schema: schema, context_app: ctx_app} = context) do prefix = Module.concat(context.web_module, schema.web_namespace) web_path = Mix.Phoenix.web_path(ctx_app) if schema.web_namespace do Mix.shell().info(""" Add the live routes to your #{schema.web_namespace} :browser scope in #{web_path}/router.ex: scope "/#{schema.web_path}", #{inspect(prefix)} do pipe_through :browser ... #{for line <- live_route_instructions(schema), do: " #{line}"} end """) else Mix.shell().info(""" Add the live routes to your browser scope in #{Mix.Phoenix.web_path(ctx_app)}/router.ex: #{for line <- live_route_instructions(schema), do: " #{line}"} """) end if schema.scope do Mix.shell().info( "Ensure the routes are defined in a block that sets the `#{inspect(context.scope.assign_key)}` assign." ) end if context.generate?, do: Gen.Context.print_shell_instructions(context) maybe_print_upgrade_info() end defp maybe_print_upgrade_info do unless Code.ensure_loaded?(Phoenix.LiveView.JS) do Mix.shell().info(""" You must update :phoenix_live_view to v0.18 or later and :phoenix_live_dashboard to v0.7 or later to use the features in this generator. """) end end defp live_route_instructions(schema) do route_base = if schema.scope && schema.scope.route_prefix do scope_prefix = schema.scope.route_prefix "#{scope_prefix}/#{schema.plural}" else "/#{schema.plural}" end [ ~s|live "#{route_base}", #{inspect(schema.alias)}Live.Index, :index\n|, ~s|live "#{route_base}/new", #{inspect(schema.alias)}Live.Form, :new\n|, ~s|live "#{route_base}/:#{schema.opts[:primary_key] || :id}", #{inspect(schema.alias)}Live.Show, :show\n|, ~s|live "#{route_base}/:#{schema.opts[:primary_key] || :id}/edit", #{inspect(schema.alias)}Live.Form, :edit| ] end @doc false def inputs(%Schema{} = schema) do schema.attrs |> Enum.reject(fn {_key, type} -> type == :map end) |> Enum.map(fn {_, {:references, _}} -> nil {key, :integer} -> ~s(<.input field={@form[#{inspect(key)}]} type="number" label="#{label(key)}" />) {key, :float} -> ~s(<.input field={@form[#{inspect(key)}]} type="number" label="#{label(key)}" step="any" />) {key, :decimal} -> ~s(<.input field={@form[#{inspect(key)}]} type="number" label="#{label(key)}" step="any" />) {key, :boolean} -> ~s(<.input field={@form[#{inspect(key)}]} type="checkbox" label="#{label(key)}" />) {key, :text} -> ~s(<.input field={@form[#{inspect(key)}]} type="textarea" label="#{label(key)}" />) {key, :date} -> ~s(<.input field={@form[#{inspect(key)}]} type="date" label="#{label(key)}" />) {key, :time} -> ~s(<.input field={@form[#{inspect(key)}]} type="time" label="#{label(key)}" />) {key, :utc_datetime} -> ~s(<.input field={@form[#{inspect(key)}]} type="datetime-local" label="#{label(key)}" />) {key, :naive_datetime} -> ~s(<.input field={@form[#{inspect(key)}]} type="datetime-local" label="#{label(key)}" />) {key, {:array, _} = type} -> ~s""" <.input field={@form[#{inspect(key)}]} type="select" multiple label="#{label(key)}" options={#{inspect(default_options(type))}} /> """ {key, {:enum, _}} -> ~s""" <.input field={@form[#{inspect(key)}]} type="select" label="#{label(key)}" prompt="Choose a value" options={Ecto.Enum.values(#{inspect(schema.module)}, #{inspect(key)})} /> """ {key, _} -> ~s(<.input field={@form[#{inspect(key)}]} type="text" label="#{label(key)}" />) end) end defp default_options({:array, :string}), do: Enum.map([1, 2], &{"Option #{&1}", "option#{&1}"}) defp default_options({:array, :integer}), do: Enum.map([1, 2], &{"#{&1}", &1}) defp default_options({:array, _}), do: [] defp label(key), do: Phoenix.Naming.humanize(to_string(key)) defp scope_param(%{scope: nil}), do: "" defp scope_param(%{scope: %{route_prefix: route_prefix}}) when not is_nil(route_prefix), do: "scope" defp scope_param(_), do: "_scope" defp scope_param_prefix(schema) do param = scope_param(schema) if param != "", do: "#{param}, ", else: "" end defp scope_assign_route_prefix( %{scope: %{route_prefix: route_prefix, assign_key: assign_key}} = schema ) when not is_nil(route_prefix) do Scope.route_prefix("@#{assign_key}", schema) end defp scope_assign_route_prefix(_), do: "" end ================================================ FILE: lib/mix/tasks/phx.gen.notifier.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Notifier do @shortdoc "Generates a notifier that delivers emails by default" @moduledoc """ Generates a notifier that delivers emails by default. $ mix phx.gen.notifier Accounts User welcome_user reset_password confirmation_instructions This task expects a context module name, followed by a notifier name and one or more message names. Messages are the functions that will be created prefixed by "deliver", so the message name should be "snake_case" without punctuation. Additionally a context app can be specified with the flag `--context-app`, which is useful if the notifier is being generated in a different app under an umbrella. $ mix phx.gen.notifier Accounts User welcome_user --context-app marketing The app "marketing" must exist before the command is executed. """ use Mix.Task @switches [ context: :boolean, context_app: :string, prefix: :string ] @default_opts [context: true] alias Mix.Phoenix.Context @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.notifier must be invoked from within your *_web application root directory" ) end {context, notifier_module, messages} = build(args) inflections = Mix.Phoenix.inflect(notifier_module) binding = [ context: context, inflections: inflections, notifier_messages: messages ] paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(context) if "--no-compile" not in args do Mix.Task.run("compile") end context |> copy_new_files(binding, paths) |> maybe_print_mailer_installation_instructions() end @doc false def build(args, help \\ __MODULE__) do {opts, parsed, _} = parse_opts(args) [context_name, notifier_name | notifier_messages] = validate_args!(parsed, help) notifier_module = inspect(Module.concat(context_name, "#{notifier_name}Notifier")) context = Context.new(notifier_module, opts) {context, notifier_module, notifier_messages} end defp parse_opts(args) do {opts, parsed, invalid} = OptionParser.parse(args, switches: @switches) merged_opts = @default_opts |> Keyword.merge(opts) |> put_context_app(opts[:context_app]) {merged_opts, parsed, invalid} end defp put_context_app(opts, nil), do: opts defp put_context_app(opts, string) do Keyword.put(opts, :context_app, String.to_atom(string)) end defp validate_args!([context, notifier | messages] = args, help) do cond do not Context.valid?(context) -> help.raise_with_help( "Expected the context, #{inspect(context)}, to be a valid module name" ) not valid_notifier?(notifier) -> help.raise_with_help( "Expected the notifier, #{inspect(notifier)}, to be a valid module name" ) context == Mix.Phoenix.base() -> help.raise_with_help( "Cannot generate context #{context} because it has the same name as the application" ) notifier == Mix.Phoenix.base() -> help.raise_with_help( "Cannot generate notifier #{notifier} because it has the same name as the application" ) Enum.any?(messages, &(!valid_message?(&1))) -> help.raise_with_help( "Cannot generate notifier #{inspect(notifier)} because one of the messages is invalid: #{Enum.map_join(messages, ", ", &inspect/1)}" ) true -> args end end defp validate_args!(_, help) do help.raise_with_help("Invalid arguments") end defp valid_notifier?(notifier) do notifier =~ ~r/^[A-Z]\w*(\.[A-Z]\w*)*$/ end defp valid_message?(message_name) do message_name =~ ~r/^[a-z]+(\_[a-z0-9]+)*$/ end @doc false @spec raise_with_help(String.t()) :: no_return() def raise_with_help(msg) do Mix.raise(""" #{msg} mix phx.gen.notifier expects a context module name, followed by a notifier name and one or more message names. Messages are the functions that will be created prefixed by "deliver", so the message name should be "snake_case" without punctuation. For example: mix phx.gen.notifier Accounts User welcome reset_password In this example the notifier will be called `UserNotifier` inside the Accounts context. The functions `deliver_welcome/1` and `reset_password/1` will be created inside this notifier. """) end defp copy_new_files(%Context{} = context, binding, paths) do files = files_to_be_generated(context) Mix.Phoenix.copy_from(paths, "priv/templates/phx.gen.notifier", binding, files) context end defp files_to_be_generated(%Context{} = context) do [ {:eex, "notifier.ex.eex", context.file}, {:eex, "notifier_test.exs.eex", context.test_file} ] end defp prompt_for_conflicts(context) do context |> files_to_be_generated() |> Mix.Phoenix.prompt_for_conflicts() end @doc false @spec maybe_print_mailer_installation_instructions(%Context{}) :: %Context{} def maybe_print_mailer_installation_instructions(%Context{} = context) do mailer_module = Module.concat([context.base_module, "Mailer"]) unless Code.ensure_loaded?(mailer_module) do Mix.shell().info(""" Unable to find the "#{inspect(mailer_module)}" module defined. A mailer module like the following is expected to be defined in your application in order to send emails. defmodule #{inspect(mailer_module)} do use Swoosh.Mailer, otp_app: #{inspect(context.context_app)} end It is also necessary to add "swoosh" as a dependency in your "mix.exs" file: def deps do [{:swoosh, "~> 1.4"}] end Finally, an adapter needs to be set in your configuration: import Config config #{inspect(context.context_app)}, #{inspect(mailer_module)}, adapter: Swoosh.Adapters.Local Check https://hexdocs.pm/swoosh for more details. """) end context end end ================================================ FILE: lib/mix/tasks/phx.gen.presence.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Presence do @shortdoc "Generates a Presence tracker" @moduledoc """ Generates a Presence tracker. $ mix phx.gen.presence $ mix phx.gen.presence MyPresence The argument, which defaults to `Presence`, defines the module name of the Presence tracker. Generates a new file, `lib/my_app_web/channels/my_presence.ex`, where `my_presence` is the snake-cased version of the provided module name. """ use Mix.Task @doc false def run([]) do run(["Presence"]) end def run([alias_name]) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.presence must be invoked from within your *_web application's root directory" ) end context_app = Mix.Phoenix.context_app() otp_app = Mix.Phoenix.otp_app() web_prefix = Mix.Phoenix.web_path(context_app) inflections = Mix.Phoenix.inflect(alias_name) inflections = Keyword.put(inflections, :module, "#{inflections[:web_module]}.#{inflections[:scoped]}") binding = inflections ++ [ otp_app: otp_app, pubsub_server: Module.concat(Mix.Phoenix.context_base(context_app), "PubSub") ] files = [ {:eex, "presence.ex.eex", Path.join(web_prefix, "channels/#{binding[:path]}.ex")} ] Mix.Phoenix.copy_from(paths(), "priv/templates/phx.gen.presence", binding, files) Mix.shell().info(""" Add your new module to your supervision tree, in lib/#{otp_app}/application.ex: children = [ ... #{binding[:module]} ] You're all set! See the Phoenix.Presence docs for more details: https://hexdocs.pm/phoenix/Phoenix.Presence.html """) end defp paths do [".", :phoenix] end end ================================================ FILE: lib/mix/tasks/phx.gen.release.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Release do @shortdoc "Generates release files and optional Dockerfile for release-based deployments" @moduledoc """ Generates release files and optional Dockerfile for release-based deployments. The following release files are created: * `lib/app_name/release.ex` - A release module containing tasks for running migrations inside a release * `rel/overlays/bin/migrate` - A migrate script for conveniently invoking the release system migrations * `rel/overlays/bin/server` - A server script for conveniently invoking the release system with environment variables to start the phoenix web server Note, the `rel/overlays` directory is copied into the release build by default when running `mix release`. To skip generating the migration-related files, use the `--no-ecto` flag. To force these migration-related files to be generated, use the `--ecto` flag. ## Docker When the `--docker` flag is passed, the following docker files are generated: * `Dockerfile` - The Dockerfile for use in any standard docker deployment * `.dockerignore` - A docker ignore file with standard elixir defaults By default, the build uses whatever base image matches your development system’s active versions at generation time. To override those defaults, specify: * `otp` — the OTP version to use * `elixir` — the Elixir version to use For extended release configuration, the `mix release.init` task can be used in addition to this task. See the `Mix.Release` docs for more details. If you are using third party JS package managers like `npm` or `yarn`, you will need to update the generated Dockerfile with an extra step to fetch those packages. This might look like this: ```dockerfile ... ARG RUNNER_IMAGE="debian:..." FROM node:20 as node COPY assets assets RUN cd assets && npm install FROM ${BUILDER_IMAGE} as builder ... COPY assets assets COPY --from=node assets/node_modules assets/node_modules ... ``` If you are using esbuild through Node.js or other JavaScript build tools, the approach above can also be modified to invoke those in the node stage, for example: ```dockerfile FROM node:20 as node COPY assets assets RUN cd assets && npm install && node build.js --deploy ``` Note that you may need to adjust the `assets.deploy` task to not invoke Node.js again. """ use Mix.Task require Logger @doc false def run(args) do opts = parse_args(args) if Mix.Project.umbrella?() do Mix.raise(""" mix phx.gen.release is not supported in umbrella applications. Run this task in your web application instead. """) end app = Mix.Phoenix.otp_app() app_namespace = Mix.Phoenix.base() web_namespace = app_namespace |> Mix.Phoenix.web_module() |> inspect() binding = [ app_namespace: app_namespace, otp_app: app, assets_dir_exists?: File.dir?("assets") ] Mix.Phoenix.copy_from(paths(), "priv/templates/phx.gen.release", binding, [ {:eex, "rel/server.sh.eex", "rel/overlays/bin/server"}, {:eex, "rel/server.bat.eex", "rel/overlays/bin/server.bat"} ]) if opts.ecto do Mix.Phoenix.copy_from(paths(), "priv/templates/phx.gen.release", binding, [ {:eex, "rel/migrate.sh.eex", "rel/overlays/bin/migrate"}, {:eex, "rel/migrate.bat.eex", "rel/overlays/bin/migrate.bat"}, {:eex, "release.ex.eex", Mix.Phoenix.context_lib_path(app, "release.ex")} ]) end if opts.docker do gen_docker(binding, opts) end File.chmod!("rel/overlays/bin/server", 0o755) File.chmod!("rel/overlays/bin/server.bat", 0o755) if opts.ecto do File.chmod!("rel/overlays/bin/migrate", 0o755) File.chmod!("rel/overlays/bin/migrate.bat", 0o755) end Mix.shell().info(""" Your application is ready to be deployed in a release! See https://hexdocs.pm/mix/Mix.Tasks.Release.html for more information about Elixir releases. #{if opts.docker, do: docker_instructions()} Here are some useful release commands you can run in any release environment: # To build a release mix release # To start your system with the Phoenix server running _build/dev/rel/#{app}/bin/server #{if opts.ecto, do: ecto_instructions(app)} Once the release is running you can connect to it remotely: _build/dev/rel/#{app}/bin/#{app} remote To list all commands: _build/dev/rel/#{app}/bin/#{app} """) if opts.ecto and opts.socket_db_adaptor_installed do post_install_instructions("config/runtime.exs", ~r/ECTO_IPV6/, """ [warn] Conditional IPv6 support missing from runtime configuration. Add the following to your config/runtime.exs: maybe_ipv6 = if System.get_env("ECTO_IPV6") in ~w(true 1), do: [:inet6], else: [] config :#{app}, #{app_namespace}.Repo, ..., socket_options: maybe_ipv6 """) end post_install_instructions("config/runtime.exs", ~r/PHX_SERVER/, """ [warn] Conditional server startup is missing from runtime configuration. Add the following to the top of your config/runtime.exs: if System.get_env("PHX_SERVER") do config :#{app}, #{web_namespace}.Endpoint, server: true end """) post_install_instructions("config/runtime.exs", ~r/PHX_HOST/, """ [warn] Environment based URL export is missing from runtime configuration. Add the following to your config/runtime.exs: host = System.get_env("PHX_HOST") || "example.com" config :#{app}, #{web_namespace}.Endpoint, ..., url: [host: host, port: 443] """) end defp parse_args(args) do args |> OptionParser.parse( strict: [ecto: :boolean, docker: :boolean, elixir: :string, otp: :string] ) |> elem(0) |> Keyword.put_new_lazy(:ecto, &ecto_sql_installed?/0) |> Keyword.put_new_lazy(:socket_db_adaptor_installed, &socket_db_adaptor_installed?/0) |> Keyword.put_new(:docker, false) |> Keyword.put_new(:elixir, false) |> Keyword.put_new(:otp, false) |> Map.new() end defp ecto_instructions(app) do """ # To run migrations _build/dev/rel/#{app}/bin/migrate """ end defp docker_instructions do """ Using the generated Dockerfile, your release will be bundled into a Docker image, ready for deployment on platforms that support Docker. For more information about deploying with Docker see https://hexdocs.pm/phoenix/releases.html#containers """ end defp paths do [".", :phoenix] end defp post_install_instructions(path, matching, msg) do case File.read(path) do {:ok, content} -> unless content =~ matching, do: Mix.shell().info(msg) {:error, _} -> Mix.shell().info(msg) end end defp ecto_sql_installed?, do: Mix.Project.deps_paths() |> Map.has_key?(:ecto_sql) defp socket_db_adaptor_installed? do Mix.Project.deps_paths(depth: 1) |> Map.take([:tds, :myxql, :postgrex]) |> map_size() > 0 end @debian "trixie" defp elixir_and_debian_vsn(elixir_vsn, otp_vsn) do url = "https://hub.docker.com/v2/namespaces/hexpm/repositories/elixir/tags?name=#{elixir_vsn}-erlang-#{otp_vsn}-debian-#{@debian}-" fetch_body!(url) |> Phoenix.json_library().decode!() |> Map.fetch!("results") |> Enum.find_value(:error, fn %{"name" => name} -> if String.ends_with?(name, "-slim") do elixir_vsn = name |> String.split("-") |> List.first() %{"vsn" => vsn} = Regex.named_captures(~r/.*debian-#{@debian}-(?.*)-slim/, name) {:ok, elixir_vsn, vsn} end end) end defp gen_docker(binding, opts) do wanted_elixir_vsn = opts[:elixir] || case Version.parse!(System.version()) do %{major: major, minor: minor, pre: ["dev"]} -> "#{major}.#{minor - 1}.0" _ -> System.version() end otp_vsn = opts[:otp] || otp_vsn() vsns = case elixir_and_debian_vsn(wanted_elixir_vsn, otp_vsn) do {:ok, elixir_vsn, debian_vsn} -> {:ok, elixir_vsn, debian_vsn} :error -> case elixir_and_debian_vsn("", otp_vsn) do {:ok, elixir_vsn, debian_vsn} -> Logger.warning( "Docker image for Elixir #{wanted_elixir_vsn} not found, defaulting to Elixir #{elixir_vsn}" ) {:ok, elixir_vsn, debian_vsn} :error -> :error end end case vsns do {:ok, elixir_vsn, debian_vsn} -> binding = Keyword.merge(binding, debian: @debian, debian_vsn: debian_vsn, elixir_vsn: elixir_vsn, otp_vsn: otp_vsn ) Mix.Phoenix.copy_from(paths(), "priv/templates/phx.gen.release", binding, [ {:eex, "Dockerfile.eex", "Dockerfile"}, {:eex, "dockerignore.eex", ".dockerignore"} ]) :error -> raise """ unable to fetch supported Docker image for Elixir #{wanted_elixir_vsn} and Erlang #{otp_vsn}. Please check https://hub.docker.com/r/hexpm/elixir/tags?page=1&name=#{otp_vsn} \ for a suitable Elixir version """ end end defp ensure_app!(app) do if function_exported?(Mix, :ensure_application!, 1) do apply(Mix, :ensure_application!, [app]) else {:ok, _} = Application.ensure_all_started(app) end end defp fetch_body!(url) do url = String.to_charlist(url) Logger.debug("Fetching latest image information from #{url}") ensure_app!(:inets) ensure_app!(:ssl) if proxy = System.get_env("HTTP_PROXY") || System.get_env("http_proxy") do Logger.debug("Using HTTP_PROXY: #{proxy}") %{host: host, port: port} = URI.parse(proxy) :httpc.set_options([{:proxy, {{String.to_charlist(host), port}, []}}]) end if proxy = System.get_env("HTTPS_PROXY") || System.get_env("https_proxy") do Logger.debug("Using HTTPS_PROXY: #{proxy}") %{host: host, port: port} = URI.parse(proxy) :httpc.set_options([{:https_proxy, {{String.to_charlist(host), port}, []}}]) end # https://security.erlef.org/secure_coding_and_deployment_hardening/inets http_options = [ ssl: [ verify: :verify_peer, cacerts: :public_key.cacerts_get(), depth: 3, customize_hostname_check: [ match_fun: :public_key.pkix_verify_hostname_match_fun(:https) ], versions: protocol_versions() ] ] http_client = Process.get({__MODULE__, :http_client}, fn url -> case :httpc.request(:get, {url, []}, http_options, body_format: :binary) do {:ok, {{_, 200, _}, _headers, body}} -> body other -> raise "couldn't fetch #{url}: #{inspect(other)}" end end) http_client.(url) end defp protocol_versions do otp_major_vsn = :erlang.system_info(:otp_release) |> List.to_integer() if otp_major_vsn < 25, do: [:"tlsv1.2"], else: [:"tlsv1.2", :"tlsv1.3"] end def otp_vsn do major = to_string(:erlang.system_info(:otp_release)) path = Path.join([:code.root_dir(), "releases", major, "OTP_VERSION"]) case File.read(path) do {:ok, content} -> String.trim(content) {:error, _} -> IO.warn("unable to read OTP minor version at #{path}. Falling back to #{major}.0") "#{major}.0" end end end ================================================ FILE: lib/mix/tasks/phx.gen.schema.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Schema do @shortdoc "Generates an Ecto schema and migration file" @moduledoc """ Generates an Ecto schema and migration. $ mix phx.gen.schema Blog.Post blog_posts title:string views:integer The first argument is the schema module followed by its plural name (used as the table name). The generated schema above will contain: * a schema file in `lib/my_app/blog/post.ex`, with a `blog_posts` table * a migration file for the repository The generated migration can be skipped with `--no-migration`. ## Contexts Your schemas can be generated and added to a separate OTP app. Make sure your configuration is properly setup or manually specify the context app with the `--context-app` option with the CLI. Via config: config :marketing_web, :generators, context_app: :marketing Via CLI: $ mix phx.gen.schema Blog.Post blog_posts title:string views:integer --context-app marketing ## Attributes The resource fields are given using `name:type` syntax where type are the types supported by Ecto. Omitting the type makes it default to `:string`: $ mix phx.gen.schema Blog.Post blog_posts title views:integer The following types are supported: #{for attr <- Mix.Phoenix.Schema.valid_types(), do: " * `#{inspect attr}`\n"} * `:datetime` - An alias for `:naive_datetime` The generator also supports references, which we will properly associate the given column to the primary key column of the referenced table: $ mix phx.gen.schema Blog.Post blog_posts title user_id:references:users This will result in a migration with an `:integer` column of `:user_id` and create an index. Furthermore an array type can also be given if it is supported by your database, although it requires the type of the underlying array element to be given too: $ mix phx.gen.schema Blog.Post blog_posts tags:array:string Unique columns can be automatically generated by using: $ mix phx.gen.schema Blog.Post blog_posts title:unique unique_int:integer:unique Redact columns can be automatically generated by using: $ mix phx.gen.schema Accounts.Superhero superheroes secret_identity:redact password:string:redact Ecto.Enum fields can be generated by using: $ mix phx.gen.schema Blog.Post blog_posts title status:enum:unpublished:published:deleted If no data type is given, it defaults to a string. ## table By default, the table name for the migration and schema will be the plural name provided for the resource. To customize this value, a `--table` option may be provided. For example: $ mix phx.gen.schema Blog.Post posts --table cms_posts ## binary_id Generated migration can use `binary_id` for schema's primary key and its references with option `--binary-id`. ## primary_key By default, the primary key in the table is called `id`. This option allows to change the name of the primary key column. For example: $ mix phx.gen.schema Blog.post posts --primary-key post_id ## repo Generated migration can use `repo` to set the migration repository folder with option `--repo`: $ mix phx.gen.schema Blog.Post posts --repo MyApp.Repo.Auth ## migration_dir Generated migrations can be added to a specific `--migration-dir` which sets the migration folder path: $ mix phx.gen.schema Blog.Post posts --migration-dir /path/to/directory ## prefix By default migrations and schemas are generated without a prefix. For PostgreSQL this sets the "SCHEMA" (typically set via `search_path`) and for MySQL it sets the database for the generated migration and schema. The prefix can be used to thematically organize your tables on the database level. A prefix can be specified with the `--prefix` flags. For example: $ mix phx.gen.schema Blog.Post posts --prefix blog > #### Warning {: .warning} > > The flag does not generate migrations to create the schema / database. > This needs to be done manually or in a separate migration. ## Default options This generator uses default options provided in the `:generators` configuration of your application. These are the defaults: config :your_app, :generators, migration: true, binary_id: false, timestamp_type: :naive_datetime, sample_binary_id: "11111111-1111-1111-1111-111111111111" You can override those options per invocation by providing corresponding switches, e.g. `--no-binary-id` to use normal ids despite the default configuration or `--migration` to force generation of the migration. ## UTC timestamps By setting the `:timestamp_type` to `:utc_datetime`, the timestamps will be created using the UTC timezone. This results in a `DateTime` struct instead of a `NaiveDateTime`. This can also be set to `:utc_datetime_usec` for microsecond precision. """ use Mix.Task alias Mix.Phoenix.Schema @switches [migration: :boolean, binary_id: :boolean, table: :string, web: :string, context_app: :string, prefix: :string, repo: :string, migration_dir: :string, primary_key: :string, scope: :string, no_scope: :boolean] @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise "mix phx.gen.schema must be invoked from within your *_web application root directory" end schema = build(args, []) paths = Mix.Phoenix.generator_paths() prompt_for_conflicts(schema) binding = [ schema: schema, primary_key: schema.opts[:primary_key] || :id, scope: schema.scope ] schema |> copy_new_files(paths, binding) |> print_shell_instructions() end defp prompt_for_conflicts(schema) do schema |> files_to_be_generated() |> Mix.Phoenix.prompt_for_conflicts() end @doc false def build(args, parent_opts, help \\ __MODULE__) do {schema_opts, parsed, _} = OptionParser.parse(args, switches: @switches) [schema_name, plural | attrs] = validate_args!(parsed, help) opts = parent_opts |> Keyword.merge(schema_opts) |> put_context_app(schema_opts[:context_app]) |> maybe_update_repo_module() Schema.new(schema_name, plural, attrs, opts) end defp maybe_update_repo_module(opts) do if is_nil(opts[:repo]) do opts else Keyword.update!(opts, :repo, &Module.concat([&1])) end end defp put_context_app(opts, nil), do: opts defp put_context_app(opts, string) do Keyword.put(opts, :context_app, String.to_atom(string)) end @doc false def files_to_be_generated(%Schema{} = schema) do [{:eex, "schema.ex.eex", schema.file}] end @doc false def copy_new_files(%Schema{context_app: ctx_app, repo: repo, opts: opts} = schema, paths, binding) do files = files_to_be_generated(schema) Mix.Phoenix.copy_from(paths, "priv/templates/phx.gen.schema", binding, files) if schema.migration? do migration_dir = cond do migration_dir = opts[:migration_dir] -> migration_dir opts[:repo] -> repo_name = repo |> Module.split() |> List.last() |> Macro.underscore() Mix.Phoenix.context_app_path(ctx_app, "priv/#{repo_name}/migrations/") true -> Mix.Phoenix.context_app_path(ctx_app, "priv/repo/migrations/") end migration_path = Path.join(migration_dir, "#{timestamp()}_create_#{schema.table}.exs") Mix.Phoenix.copy_from paths, "priv/templates/phx.gen.schema", binding, [ {:eex, "migration.exs.eex", migration_path}, ] end schema end @doc false def print_shell_instructions(%Schema{} = schema) do if schema.migration? do Mix.shell().info """ Remember to update your repository by running migrations: $ mix ecto.migrate """ end end @doc false def validate_args!([schema, plural | _] = args, help) do cond do not Schema.valid?(schema) -> help.raise_with_help "Expected the schema argument, #{inspect schema}, to be a valid module name" String.contains?(plural, ":") or plural != Phoenix.Naming.underscore(plural) -> help.raise_with_help "Expected the plural argument, #{inspect plural}, to be all lowercase using snake_case convention" true -> args end end def validate_args!(_, help) do help.raise_with_help "Invalid arguments" end @doc false @spec raise_with_help(String.t) :: no_return() def raise_with_help(msg) do Mix.raise """ #{msg} mix phx.gen.schema expects both a module name and the plural of the generated resource followed by any number of attributes: mix phx.gen.schema Blog.Post blog_posts title:string """ end defp timestamp do {{y, m, d}, {hh, mm, ss}} = :calendar.universal_time() "#{y}#{pad(m)}#{pad(d)}#{pad(hh)}#{pad(mm)}#{pad(ss)}" end defp pad(i) when i < 10, do: << ?0, ?0 + i >> defp pad(i), do: to_string(i) end ================================================ FILE: lib/mix/tasks/phx.gen.secret.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Secret do @shortdoc "Generates a secret" @moduledoc """ Generates a secret and prints it to the terminal. $ mix phx.gen.secret [length] By default, mix phx.gen.secret generates a key 64 characters long. The minimum value for `length` is 32. """ use Mix.Task @doc false def run([]), do: run(["64"]) def run([int]), do: int |> parse!() |> random_string() |> Mix.shell().info() def run([_|_]), do: invalid_args!() defp parse!(int) do case Integer.parse(int) do {int, ""} -> int _ -> invalid_args!() end end defp random_string(length) when length > 31 do :crypto.strong_rand_bytes(length) |> Base.encode64(padding: false) |> binary_part(0, length) end defp random_string(_), do: Mix.raise "The secret should be at least 32 characters long" @spec invalid_args!() :: no_return() defp invalid_args! do Mix.raise "mix phx.gen.secret expects a length as integer or no argument at all" end end ================================================ FILE: lib/mix/tasks/phx.gen.socket.ex ================================================ defmodule Mix.Tasks.Phx.Gen.Socket do @shortdoc "Generates a Phoenix socket handler" @moduledoc """ Generates a Phoenix socket handler. $ mix phx.gen.socket User Accepts the module name for the socket. The generated files will contain: For a regular application: * a client in `assets/js` * a socket in `lib/my_app_web/channels` For an umbrella application: * a client in `apps/my_app_web/assets/js` * a socket in `apps/my_app_web/lib/my_app_web/channels` You can then generate channels with `mix phx.gen.channel`. """ use Mix.Task @doc false def run(args) do if Mix.Project.umbrella?() do Mix.raise( "mix phx.gen.socket must be invoked from within your *_web application's root directory" ) end [socket_name, pre_existing_channel] = validate_args!(args) context_app = Mix.Phoenix.context_app() web_prefix = Mix.Phoenix.web_path(context_app) binding = Mix.Phoenix.inflect(socket_name) existing_channel = if pre_existing_channel do channel_binding = Mix.Phoenix.inflect(pre_existing_channel) Keyword.put( channel_binding, :module, "#{channel_binding[:web_module]}.#{channel_binding[:scoped]}" ) end binding = binding |> Keyword.put(:module, "#{binding[:web_module]}.#{binding[:scoped]}") |> Keyword.put(:endpoint_module, Module.concat([binding[:web_module], Endpoint])) |> Keyword.put(:web_prefix, web_prefix) |> Keyword.put(:existing_channel, existing_channel) Mix.Phoenix.check_module_name_availability!(binding[:module] <> "Socket") Mix.Phoenix.copy_from(paths(), "priv/templates/phx.gen.socket", binding, [ {:eex, "socket.ex.eex", Path.join(web_prefix, "channels/#{binding[:path]}_socket.ex")}, {:eex, "socket.js.eex", "assets/js/#{binding[:path]}_socket.js"} ]) Mix.shell().info(""" Add the socket handler to your `#{Mix.Phoenix.web_path(context_app, "endpoint.ex")}`, for example: socket "/socket", #{binding[:module]}Socket, websocket: true, longpoll: false For the front-end integration, you need to import the `#{binding[:path]}_socket.js` in your `assets/js/app.js` file: import "./#{binding[:path]}_socket.js" """) end @spec raise_with_help() :: no_return() defp raise_with_help do Mix.raise(""" mix phx.gen.socket expects the module name: mix phx.gen.socket User """) end defp validate_args!([name, "--from-channel", pre_existing_channel]) do unless valid_name?(name) and valid_name?(pre_existing_channel) do raise_with_help() end [name, pre_existing_channel] end defp validate_args!([name]) do unless valid_name?(name) do raise_with_help() end [name, nil] end defp validate_args!(_), do: raise_with_help() defp valid_name?(name) do name =~ ~r/^[A-Z]\w*(\.[A-Z]\w*)*$/ end defp paths do [".", :phoenix] end end ================================================ FILE: lib/mix/tasks/phx.routes.ex ================================================ defmodule Mix.Tasks.Phx.Routes do use Mix.Task alias Phoenix.Router.ConsoleFormatter @shortdoc "Prints all routes" @moduledoc """ Prints all routes for the default or a given router. Can also locate the controller function behind a specified url. $ mix phx.routes [ROUTER] [--info URL] The default router is inflected from the application name unless a configuration named `:namespace` is set inside your application configuration. For example, the configuration: config :my_app, namespace: My.App will exhibit the routes for `My.App.Router` when this task is invoked without arguments. Umbrella projects do not have a default router and therefore always expect a router to be given. An alias can be added to mix.exs to automate this: defp aliases do [ "phx.routes": "phx.routes MyAppWeb.Router", # aliases... ] ## Options * `--info` - locate the controller function definition called by the given url * `--method` - what HTTP method to use with the given url, only works when used with `--info` and defaults to `get` ## Examples Print all routes for the default router: $ mix phx.routes Print all routes for the given router: $ mix phx.routes MyApp.AnotherRouter Print information about the controller function called by a specified url: $ mix phx.routes --info http://0.0.0.0:4000/home Module: RouteInfoTestWeb.PageController Function: :index /home/my_app/controllers/page_controller.ex:4 Print information about the controller function called by a specified url and HTTP method: $ mix phx.routes --info http://0.0.0.0:4000/users --method post Module: RouteInfoTestWeb.UserController Function: :create /home/my_app/controllers/user_controller.ex:24 """ @doc false def run(args, base \\ Mix.Phoenix.base()) do if "--no-compile" not in args do Mix.Task.run("compile") end Mix.Task.reenable("phx.routes") {opts, args, _} = OptionParser.parse(args, switches: [endpoint: :string, router: :string, info: :string]) {router_mod, endpoint_mod} = case args do [passed_router] -> {router(passed_router, base), opts[:endpoint]} [] -> {router(opts[:router], base), endpoint(opts[:endpoint], base)} end case Keyword.fetch(opts, :info) do {:ok, url} -> get_url_info(url, {router_mod, opts}) :error -> router_mod |> ConsoleFormatter.format(endpoint_mod) |> Mix.shell().info() end end def get_url_info(url, {router_mod, opts}) do %{path: path} = URI.parse(url) method = opts |> Keyword.get(:method, "get") |> String.upcase() meta = Phoenix.Router.route_info(router_mod, method, path, "") %{plug: plug, plug_opts: plug_opts} = meta {module, func_name} = case meta[:mfa] do {mod, fun, _} -> {mod, fun} _ -> {plug, plug_opts} end Mix.shell().info("Module: #{inspect(module)}") if func_name, do: Mix.shell().info("Function: #{inspect(func_name)}") file_path = get_file_path(module) if line = get_line_number(module, func_name) do Mix.shell().info("#{file_path}:#{line}") else Mix.shell().info("#{file_path}") end end defp endpoint(nil, base) do loaded(web_mod(base, "Endpoint")) end defp endpoint(module, _base) do loaded(Module.concat([module])) end defp router(nil, base) do if Mix.Project.umbrella?() do Mix.raise(""" umbrella applications require an explicit router to be given to phx.routes, for example: $ mix phx.routes MyAppWeb.Router An alias can be added to mix.exs aliases to automate this: "phx.routes": "phx.routes MyAppWeb.Router" """) end web_router = web_mod(base, "Router") old_router = app_mod(base, "Router") loaded(web_router) || loaded(old_router) || Mix.raise(""" no router found at #{inspect(web_router)} or #{inspect(old_router)}. An explicit router module may be given to phx.routes, for example: $ mix phx.routes MyAppWeb.Router An alias can be added to mix.exs aliases to automate this: "phx.routes": "phx.routes MyAppWeb.Router" """) end defp router(router_name, _base) do arg_router = Module.concat([router_name]) loaded(arg_router) || Mix.raise("the provided router, #{inspect(arg_router)}, does not exist") end defp loaded(module) do if Code.ensure_loaded?(module), do: module end defp app_mod(base, name), do: Module.concat([base, name]) defp web_mod(base, name), do: Module.concat(["#{base}Web", name]) defp get_file_path(module_name) do [compile_infos] = Keyword.get_values(module_name.module_info(), :compile) [source] = Keyword.get_values(compile_infos, :source) Path.relative_to_cwd(source) end defp get_line_number(_, nil), do: nil defp get_line_number(module, function_name) do {_, _, _, _, _, _, functions_list} = Code.fetch_docs(module) function_infos = functions_list |> Enum.find(fn {{type, name, _}, _, _, _, _} -> type == :function and name == function_name end) case function_infos do {_, anno, _, _, _} -> :erl_anno.line(anno) nil -> nil end end end ================================================ FILE: lib/mix/tasks/phx.server.ex ================================================ defmodule Mix.Tasks.Phx.Server do use Mix.Task @shortdoc "Starts applications and their servers" @moduledoc """ Starts the application by configuring all endpoints servers to run. Note: to start the endpoint without using this mix task you must set `server: true` in your `Phoenix.Endpoint` configuration. ## Command line options * `--open` - open browser window for each started endpoint Furthermore, this task accepts the same command-line options as `mix run`. For example, to run `phx.server` without recompiling: $ mix phx.server --no-compile The `--no-halt` flag is automatically added. Note that the `--no-deps-check` flag cannot be used this way, because Mix needs to check dependencies to find `phx.server`. To run `phx.server` without checking dependencies, you can run: $ mix do deps.loadpaths --no-deps-check, phx.server """ @impl true def run(args) do Application.put_env(:phoenix, :serve_endpoints, true, persistent: true) Mix.Tasks.Run.run(run_args() ++ open_args(args)) end defp iex_running? do Code.ensure_loaded?(IEx) and IEx.started?() end defp open_args(args) do if "--open" in args do Application.put_env(:phoenix, :browser_open, true) args -- ["--open"] else args end end defp run_args do if iex_running?(), do: [], else: ["--no-halt"] end end ================================================ FILE: lib/phoenix/channel/server.ex ================================================ defmodule Phoenix.Channel.Server do @moduledoc false use GenServer, restart: :temporary require Logger alias Phoenix.PubSub alias Phoenix.Socket alias Phoenix.Socket.{Broadcast, Message, Reply, PoolSupervisor} ## Socket API @doc """ Joins the channel in socket with authentication payload. """ @spec join(Socket.t(), module, Message.t(), keyword) :: {:ok, term, pid} | {:error, term} def join(socket, channel, message, opts) do %{topic: topic, payload: payload, ref: ref, join_ref: join_ref} = message starter = opts[:starter] || (&PoolSupervisor.start_child/3) assigns = Map.merge(socket.assigns, Keyword.get(opts, :assigns, %{})) socket = %{ socket | topic: topic, channel: channel, join_ref: join_ref || ref, assigns: assigns } ref = make_ref() from = {self(), ref} child_spec = channel.child_spec({socket.endpoint, from}) case starter.(socket, from, child_spec) do {:ok, pid} -> send(pid, {Phoenix.Channel, payload, from, socket}) mon_ref = Process.monitor(pid) receive do {^ref, {:ok, reply}} -> Process.demonitor(mon_ref, [:flush]) {:ok, reply, pid} {^ref, {:error, reply}} -> Process.demonitor(mon_ref, [:flush]) {:error, reply} {:DOWN, ^mon_ref, _, _, reason} -> Logger.error(fn -> Exception.format_exit(reason) end) {:error, %{reason: "join crashed"}} end {:error, reason} -> Logger.error(fn -> Exception.format_exit(reason) end) {:error, %{reason: "join crashed"}} end end @doc """ Gets the socket from the channel. Used by channel tests. """ @spec socket(pid) :: Socket.t() def socket(pid) do GenServer.call(pid, :socket) end @doc """ Emulates the socket being closed. Used by channel tests. """ @spec close(pid, timeout) :: :ok def close(pid, timeout) do GenServer.cast(pid, :close) ref = Process.monitor(pid) receive do {:DOWN, ^ref, _, _, _} -> :ok after timeout -> Process.exit(pid, :kill) receive do: ({:DOWN, ^ref, _, _, _} -> :ok) end end ## Channel API @doc """ Hook invoked by Phoenix.PubSub dispatch. """ def dispatch(subscribers, from, %Broadcast{event: event} = msg) do Enum.reduce(subscribers, %{}, fn {pid, _}, cache when pid == from -> cache {pid, {:fastlane, fastlane_pid, serializer, event_intercepts}}, cache -> if event in event_intercepts do send(pid, msg) cache else case cache do %{^serializer => encoded_msg} -> send(fastlane_pid, encoded_msg) cache %{} -> encoded_msg = serializer.fastlane!(msg) send(fastlane_pid, encoded_msg) Map.put(cache, serializer, encoded_msg) end end {pid, _}, cache -> send(pid, msg) cache end) :ok end def dispatch(entries, :none, message) do for {pid, _} <- entries do send(pid, message) end :ok end def dispatch(entries, from, message) do for {pid, _} <- entries, pid != from do send(pid, message) end :ok end @doc """ Broadcasts on the given pubsub server with the given `topic`, `event` and `payload`. The message is encoded as `Phoenix.Socket.Broadcast`. """ def broadcast(pubsub_server, topic, event, payload) when is_binary(topic) and is_binary(event) do broadcast = %Broadcast{ topic: topic, event: event, payload: payload } PubSub.broadcast(pubsub_server, topic, broadcast, __MODULE__) end @doc """ Broadcasts on the given pubsub server with the given `topic`, `event` and `payload`. Raises in case of crashes. """ def broadcast!(pubsub_server, topic, event, payload) when is_binary(topic) and is_binary(event) do broadcast = %Broadcast{ topic: topic, event: event, payload: payload } PubSub.broadcast!(pubsub_server, topic, broadcast, __MODULE__) end @doc """ Broadcasts on the given pubsub server with the given `from`, `topic`, `event` and `payload`. The message is encoded as `Phoenix.Socket.Broadcast`. """ def broadcast_from(pubsub_server, from, topic, event, payload) when is_binary(topic) and is_binary(event) do broadcast = %Broadcast{ topic: topic, event: event, payload: payload } PubSub.broadcast_from(pubsub_server, from, topic, broadcast, __MODULE__) end @doc """ Broadcasts on the given pubsub server with the given `from`, `topic`, `event` and `payload`. Raises in case of crashes. """ def broadcast_from!(pubsub_server, from, topic, event, payload) when is_binary(topic) and is_binary(event) do broadcast = %Broadcast{ topic: topic, event: event, payload: payload } PubSub.broadcast_from!(pubsub_server, from, topic, broadcast, __MODULE__) end @doc """ Broadcasts on the given pubsub server with the given `topic`, `event` and `payload`. The message is encoded as `Phoenix.Socket.Broadcast`. """ def local_broadcast(pubsub_server, topic, event, payload) when is_binary(topic) and is_binary(event) do broadcast = %Broadcast{ topic: topic, event: event, payload: payload } PubSub.local_broadcast(pubsub_server, topic, broadcast, __MODULE__) end @doc """ Broadcasts on the given pubsub server with the given `from`, `topic`, `event` and `payload`. The message is encoded as `Phoenix.Socket.Broadcast`. """ def local_broadcast_from(pubsub_server, from, topic, event, payload) when is_binary(topic) and is_binary(event) do broadcast = %Broadcast{ topic: topic, event: event, payload: payload } PubSub.local_broadcast_from(pubsub_server, from, topic, broadcast, __MODULE__) end @doc """ Pushes a message with the given topic, event and payload to the given process. Payloads are serialized before sending with the configured serializer. """ def push(pid, join_ref, topic, event, payload, serializer) when is_binary(topic) and is_binary(event) do message = %Message{join_ref: join_ref, topic: topic, event: event, payload: payload} send(pid, serializer.encode!(message)) :ok end @doc """ Replies to a given ref to the transport process. Payloads are serialized before sending with the configured serializer. """ def reply(pid, join_ref, ref, topic, {status, payload}, serializer) when is_binary(topic) do reply = %Reply{topic: topic, join_ref: join_ref, ref: ref, status: status, payload: payload} send(pid, serializer.encode!(reply)) :ok end ## Callbacks @doc false def init({_endpoint, {pid, _}}) do {:ok, Process.monitor(pid)} end @doc false def handle_call(:socket, _from, socket) do {:reply, socket, socket} end @doc false def handle_call(msg, from, socket) do msg |> socket.channel.handle_call(from, socket) |> handle_result(:handle_call) end @doc false def handle_cast(:close, socket) do {:stop, {:shutdown, :closed}, socket} end @doc false def handle_cast(msg, socket) do msg |> socket.channel.handle_cast(socket) |> handle_result(:handle_cast) end @doc false def handle_info({Phoenix.Channel, auth_payload, {pid, _} = from, socket}, ref) do Process.demonitor(ref) %{channel: channel, topic: topic, private: private} = socket Process.put(:"$initial_call", {channel, :join, 3}) Process.put(:"$callers", [pid]) # TODO: replace with Process.put_label/2 when we require Elixir 1.17 Process.put(:"$process_label", {Phoenix.Channel, channel, topic}) socket = %{ socket | channel_pid: self(), private: Map.merge(channel.__socket__(:private), private) } start = System.monotonic_time() {reply, state} = channel_join(channel, topic, auth_payload, socket) duration = System.monotonic_time() - start metadata = %{params: auth_payload, socket: socket, result: elem(reply, 0)} :telemetry.execute([:phoenix, :channel_joined], %{duration: duration}, metadata) GenServer.reply(from, reply) state end def handle_info(%Message{topic: topic, event: "phx_leave", ref: ref}, %{topic: topic} = socket) do handle_in({:stop, {:shutdown, :left}, :ok, put_in(socket.ref, ref)}) end def handle_info( %Message{topic: topic, event: event, payload: payload, ref: ref}, %{topic: topic} = socket ) do start = System.monotonic_time() result = socket.channel.handle_in(event, payload, put_in(socket.ref, ref)) duration = System.monotonic_time() - start metadata = %{ref: ref, event: event, params: payload, socket: socket} :telemetry.execute([:phoenix, :channel_handled_in], %{duration: duration}, metadata) handle_in(result) end def handle_info( %Broadcast{event: "phx_drain"}, %{transport_pid: transport_pid} = socket ) do send(transport_pid, :socket_drain) {:stop, {:shutdown, :draining}, socket} end def handle_info( %Broadcast{topic: topic, event: event, payload: payload}, %Socket{topic: topic} = socket ) do event |> socket.channel.handle_out(payload, socket) |> handle_result(:handle_out) end def handle_info({:DOWN, ref, _, _, reason}, ref) do {:stop, reason, ref} end def handle_info({:DOWN, _, _, transport_pid, reason}, %{transport_pid: transport_pid} = socket) do reason = if reason == :normal, do: {:shutdown, :closed}, else: reason {:stop, reason, socket} end def handle_info(msg, %{channel: channel} = socket) do if function_exported?(channel, :handle_info, 2) do msg |> socket.channel.handle_info(socket) |> handle_result(:handle_info) else warn_unexpected_msg(:handle_info, 2, msg, channel) {:noreply, socket} end end @doc false def code_change(old, %{channel: channel} = socket, extra) do if function_exported?(channel, :code_change, 3) do channel.code_change(old, socket, extra) else {:ok, socket} end end @doc false def terminate(reason, %{channel: channel} = socket) do if function_exported?(channel, :terminate, 2) do channel.terminate(reason, socket) else :ok end end def terminate(_reason, _socket) do :ok end ## Joins defp channel_join(channel, topic, auth_payload, socket) do case channel.join(topic, auth_payload, socket) do {:ok, socket} -> {{:ok, %{}}, init_join(socket, channel, topic)} {:ok, reply, socket} -> {{:ok, reply}, init_join(socket, channel, topic)} {:error, reply} -> {{:error, reply}, {:stop, :shutdown, socket}} other -> raise """ channel #{inspect(socket.channel)}.join/3 is expected to return one of: {:ok, Socket.t} | {:ok, reply :: map, Socket.t} | {:error, reply :: map} got #{inspect(other)} """ end end defp init_join(socket, channel, topic) do %{transport_pid: transport_pid, serializer: serializer, pubsub_server: pubsub_server} = socket unless pubsub_server do raise """ The :pubsub_server was not configured for endpoint #{inspect(socket.endpoint)}. Make sure to start a PubSub process in your application supervision tree: {Phoenix.PubSub, [name: YOURAPP.PubSub, adapter: Phoenix.PubSub.PG2]} And then add it to your endpoint config: config :YOURAPP, YOURAPPWeb.Endpoint, # ... pubsub_server: YOURAPP.PubSub """ end Process.monitor(transport_pid) fastlane = {:fastlane, transport_pid, serializer, channel.__intercepts__()} PubSub.subscribe(pubsub_server, topic, metadata: fastlane) {:noreply, %{socket | joined: true}} end ## Handle results defp handle_result({:stop, reason, socket}, _callback) do case reason do :normal -> send_socket_close(socket, reason) :shutdown -> send_socket_close(socket, reason) {:shutdown, _} -> send_socket_close(socket, reason) _ -> :noop end {:stop, reason, socket} end defp handle_result({:reply, resp, socket}, :handle_call) do {:reply, resp, socket} end defp handle_result({:noreply, socket}, callback) when callback in [:handle_call, :handle_cast] do {:noreply, socket} end defp handle_result({:noreply, socket}, _callback) do {:noreply, put_in(socket.ref, nil)} end defp handle_result({:noreply, socket, timeout_or_hibernate}, _callback) do {:noreply, put_in(socket.ref, nil), timeout_or_hibernate} end defp handle_result(result, :handle_in) do raise """ Expected handle_in/3 to return one of: {:noreply, Socket.t} | {:noreply, Socket.t, timeout | :hibernate} | {:reply, {status :: atom, response :: map}, Socket.t} | {:reply, status :: atom, Socket.t} | {:stop, reason :: term, Socket.t} | {:stop, reason :: term, {status :: atom, response :: map}, Socket.t} | {:stop, reason :: term, status :: atom, Socket.t} got #{inspect(result)} """ end defp handle_result(result, callback) do raise """ Expected #{callback} to return one of: {:noreply, Socket.t} | {:noreply, Socket.t, timeout | :hibernate} | {:stop, reason :: term, Socket.t} | got #{inspect(result)} """ end defp send_socket_close(%{transport_pid: transport_pid}, reason) do send(transport_pid, {:socket_close, self(), reason}) end ## Handle in/replies defp handle_in({:reply, reply, %Socket{} = socket}) do handle_reply(socket, reply) {:noreply, put_in(socket.ref, nil)} end defp handle_in({:stop, reason, reply, socket}) do handle_reply(socket, reply) handle_result({:stop, reason, socket}, :handle_in) end defp handle_in(other) do handle_result(other, :handle_in) end defp handle_reply(socket, {status, payload}) when is_atom(status) do reply( socket.transport_pid, socket.join_ref, socket.ref, socket.topic, {status, payload}, socket.serializer ) end defp handle_reply(socket, status) when is_atom(status) do handle_reply(socket, {status, %{}}) end defp handle_reply(_socket, reply) do raise """ Channel replies from handle_in/3 are expected to be one of: status :: atom {status :: atom, response :: map} for example: {:reply, :ok, socket} {:reply, {:ok, %{}}, socket} {:stop, :shutdown, {:error, %{}}, socket} got #{inspect(reply)} """ end defp warn_unexpected_msg(fun, arity, msg, channel) do proc = case Process.info(self(), :registered_name) do {_, []} -> self() {_, name} -> name end :error_logger.warning_msg( ~c"~p ~p received unexpected message in #{fun}/#{arity}: ~p~n", [channel, proc, msg] ) end end ================================================ FILE: lib/phoenix/channel.ex ================================================ defmodule Phoenix.Channel do @moduledoc ~S""" Defines a Phoenix Channel. Channels provide a means for bidirectional communication from clients that integrate with the `Phoenix.PubSub` layer for soft-realtime functionality. For a conceptual overview, see the [Channels guide](channels.html). ## Topics & Callbacks Every time you join a channel, you need to choose which particular topic you want to listen to. The topic is just an identifier, but by convention it is often made of two parts: `"topic:subtopic"`. Using the `"topic:subtopic"` approach pairs nicely with the `Phoenix.Socket.channel/3` allowing you to match on all topics starting with a given prefix by using a splat (the `*` character) as the last character in the topic pattern: channel "room:*", MyAppWeb.RoomChannel Any topic coming into the router with the `"room:"` prefix would dispatch to `MyAppWeb.RoomChannel` in the above example. Topics can also be pattern matched in your channels' `join/3` callback to pluck out the scoped pattern: # handles the special `"lobby"` subtopic def join("room:lobby", _payload, socket) do {:ok, socket} end # handles any other subtopic as the room ID, for example `"room:12"`, `"room:34"` def join("room:" <> room_id, _payload, socket) do {:ok, socket} end The first argument is the topic, the second argument is a map payload given by the client, and the third argument is an instance of `Phoenix.Socket`. The `socket` is provided to all channel callbacks, so check its module and documentation to learn its fields and the different ways to interact with it. ## Authorization Clients must join a channel to send and receive PubSub events on that channel. Your channels must implement a `join/3` callback that authorizes the socket for the given topic. For example, you could check if the user is allowed to join that particular room. To authorize a socket in `join/3`, return `{:ok, socket}`. To refuse authorization in `join/3`, return `{:error, reply}`. ## Incoming Events After a client has successfully joined a channel, incoming events from the client are routed through the channel's `handle_in/3` callbacks. Within these callbacks, you can perform any action. Incoming callbacks must return the `socket` to maintain ephemeral state. Typically you'll either forward a message to all listeners with `broadcast!/3` or reply directly to a client event for request/response style messaging. General message payloads are received as maps: def handle_in("new_msg", %{"uid" => uid, "body" => body}, socket) do ... {:reply, :ok, socket} end Binary data payloads are passed as a `{:binary, data}` tuple: def handle_in("file_chunk", {:binary, chunk}, socket) do ... {:reply, :ok, socket} end ## Broadcasts You can broadcast events from anywhere in your application to a topic by the `broadcast` function in the endpoint: MyAppWeb.Endpoint.broadcast!("room:13", "new_message", %{content: "hello"}) It is also possible to broadcast directly from channels. Here's an example of receiving an incoming `"new_msg"` event from one client, and broadcasting the message to all topic subscribers for this socket. def handle_in("new_msg", %{"uid" => uid, "body" => body}, socket) do broadcast!(socket, "new_msg", %{uid: uid, body: body}) {:noreply, socket} end ## Replies Replies are useful for acknowledging a client's message or responding with the results of an operation. A reply is sent only to the client connected to the current channel process. Behind the scenes, they include the client message `ref`, which allows the client to correlate the reply it receives with the message it sent. For example, imagine creating a resource and replying with the created record: def handle_in("create:post", attrs, socket) do changeset = Post.changeset(%Post{}, attrs) if changeset.valid? do post = Repo.insert!(changeset) response = MyAppWeb.PostView.render("show.json", %{post: post}) {:reply, {:ok, response}, socket} else response = MyAppWeb.ChangesetView.render("errors.json", %{changeset: changeset}) {:reply, {:error, response}, socket} end end Or you may just want to confirm that the operation succeeded: def handle_in("create:post", attrs, socket) do changeset = Post.changeset(%Post{}, attrs) if changeset.valid? do Repo.insert!(changeset) {:reply, :ok, socket} else {:reply, :error, socket} end end Binary data is also supported with replies via a `{:binary, data}` tuple: {:reply, {:ok, {:binary, bin}}, socket} If you don't want to send a reply to the client, you can return: {:noreply, socket} One situation when you might do this is if you need to reply later; see `reply/2`. ## Pushes Calling `push/3` allows you to send a message to the client which is not a reply to a specific client message. Because it is not a reply, a pushed message does not contain a client message `ref`; there is no prior client message to relate it to. Possible use cases include notifying a client that: - You've auto-saved the user's document - The user's game is ending soon - The IoT device's settings should be updated For example, you could `push/3` a message to the client in `handle_info/3` after receiving a `PubSub` message relevant to them. alias Phoenix.Socket.Broadcast def handle_info(%Broadcast{topic: _, event: event, payload: payload}, socket) do push(socket, event, payload) {:noreply, socket} end Push data can be given in the form of a map or a tagged `{:binary, data}` tuple: # client asks for their current rank. reply contains it, and client # is also pushed a leader board and a badge image def handle_in("current_rank", _, socket) do push(socket, "leaders", %{leaders: Game.get_leaders(socket.assigns.game_id)}) push(socket, "badge", {:binary, File.read!(socket.assigns.badge_path)}) {:reply, %{val: Game.get_rank(socket.assigns[:user])}, socket} end Note that in this example, `push/3` is called from `handle_in/3`; in this way you can essentially reply N times to a single message from the client. See `reply/2` for why this may be desirable. ## Intercepting Outgoing Events When an event is broadcasted with `broadcast/3`, each channel subscriber can choose to intercept the event and have their `handle_out/3` callback triggered. This allows the event's payload to be customized on a socket by socket basis to append extra information, or conditionally filter the message from being delivered. If the event is not intercepted with `Phoenix.Channel.intercept/1`, then the message is pushed directly to the client: intercept ["new_msg", "user_joined"] # for every socket subscribing to this topic, append an `is_editable` # value for client metadata. def handle_out("new_msg", msg, socket) do push(socket, "new_msg", Map.merge(msg, %{is_editable: User.can_edit_message?(socket.assigns[:user], msg)} )) {:noreply, socket} end # do not send broadcasted `"user_joined"` events if this socket's user # is ignoring the user who joined. def handle_out("user_joined", msg, socket) do unless User.ignoring?(socket.assigns[:user], msg.user_id) do push(socket, "user_joined", msg) end {:noreply, socket} end ## Terminate On termination, the channel callback `terminate/2` will be invoked with the error reason and the socket. If we are terminating because the client left, the reason will be `{:shutdown, :left}`. Similarly, if we are terminating because the client connection was closed, the reason will be `{:shutdown, :closed}`. If any of the callbacks return a `:stop` tuple, it will also trigger terminate with the reason given in the tuple. `terminate/2`, however, won't be invoked in case of errors nor in case of exits. This is the same behaviour as you find in Elixir abstractions like `GenServer` and others. Similar to `GenServer`, it would also be possible to `:trap_exit` to guarantee that `terminate/2` is invoked. This practice is not encouraged though. Generally speaking, if you want to clean something up, it is better to monitor your channel process and do the clean up from another process. All channel callbacks, including `join/3`, are called from within the channel process. Therefore, `self()` in any of them returns the PID to be monitored. ## Exit reasons when stopping a channel When the channel callbacks return a `:stop` tuple, such as: {:stop, :shutdown, socket} {:stop, {:error, :enoent}, socket} the second argument is the exit reason, which follows the same behaviour as standard `GenServer` exits. You have three options to choose from when shutting down a channel: * `:normal` - in such cases, the exit won't be logged and linked processes do not exit * `:shutdown` or `{:shutdown, term}` - in such cases, the exit won't be logged and linked processes exit with the same reason unless they're trapping exits * any other term - in such cases, the exit will be logged and linked processes exit with the same reason unless they're trapping exits ## Subscribing to external topics Sometimes you may need to programmatically subscribe a socket to external topics in addition to the internal `socket.topic`. For example, imagine you have a bidding system where a remote client dynamically sets preferences on products they want to receive bidding notifications on. Instead of requiring a unique channel process and topic per preference, a more efficient and simple approach would be to subscribe a single channel to relevant notifications via your endpoint. For example: defmodule MyAppWeb.Endpoint.NotificationChannel do use Phoenix.Channel def join("notification:" <> user_id, %{"ids" => ids}, socket) do topics = for product_id <- ids, do: "product:#{product_id}" {:ok, socket |> assign(:topics, []) |> put_new_topics(topics)} end def handle_in("watch", %{"product_id" => id}, socket) do {:reply, :ok, put_new_topics(socket, ["product:#{id}"])} end def handle_in("unwatch", %{"product_id" => id}, socket) do {:reply, :ok, MyAppWeb.Endpoint.unsubscribe("product:#{id}")} end defp put_new_topics(socket, topics) do Enum.reduce(topics, socket, fn topic, acc -> topics = acc.assigns.topics if topic in topics do acc else :ok = MyAppWeb.Endpoint.subscribe(topic) assign(acc, :topics, [topic | topics]) end end) end end Note: the caller must be responsible for preventing duplicate subscriptions. After calling `subscribe/1` from your endpoint, the same flow applies to handling regular Elixir messages within your channel. Most often, you'll simply relay the `%Phoenix.Socket.Broadcast{}` event and payload: alias Phoenix.Socket.Broadcast def handle_info(%Broadcast{topic: _, event: event, payload: payload}, socket) do push(socket, event, payload) {:noreply, socket} end ## Hibernation From Erlang/OTP 20, channels automatically hibernate to save memory after 15_000 milliseconds of inactivity. This can be customized by passing the `:hibernate_after` option to `use Phoenix.Channel`: use Phoenix.Channel, hibernate_after: 60_000 You can also set it to `:infinity` to fully disable it. ## Shutdown You can configure the shutdown behavior of each channel used when your application is shutting down by setting the `:shutdown` value on use: use Phoenix.Channel, shutdown: 5_000 It defaults to 5_000. The supported values are described under the in the `Supervisor` module docs. ## Logging By default, channel `"join"` and `"handle_in"` events are logged, using the level `:info` and `:debug`, respectively. You can change the level used for each event, or disable logs, per event type by setting the `:log_join` and `:log_handle_in` options when using `Phoenix.Channel`. For example, the following configuration logs join events as `:info`, but disables logging for incoming events: use Phoenix.Channel, log_join: :info, log_handle_in: false Note that changing an event type's level doesn't affect what is logged, unless you set it to `false`, it affects the associated level. """ alias Phoenix.Socket alias Phoenix.Channel.Server @type payload :: map | term | {:binary, binary} @type reply :: status :: atom | {status :: atom, response :: payload} @type socket_ref :: {transport_pid :: Pid, serializer :: module, topic :: binary, ref :: binary, join_ref :: binary} @doc """ Handle channel joins by `topic`. To authorize a socket, return `{:ok, socket}` or `{:ok, reply, socket}`. To refuse authorization, return `{:error, reason}`. Payloads are serialized before sending with the configured serializer. ## Example def join("room:lobby", payload, socket) do if authorized?(payload) do {:ok, socket} else {:error, %{reason: "unauthorized"}} end end """ @callback join(topic :: binary, payload :: payload, socket :: Socket.t()) :: {:ok, Socket.t()} | {:ok, reply :: payload, Socket.t()} | {:error, reason :: map} @doc """ Handle incoming `event`s. Payloads are serialized before sending with the configured serializer. ## Example def handle_in("ping", payload, socket) do {:reply, {:ok, payload}, socket} end """ @callback handle_in(event :: String.t(), payload :: payload, socket :: Socket.t()) :: {:noreply, Socket.t()} | {:noreply, Socket.t(), timeout | :hibernate} | {:reply, reply, Socket.t()} | {:stop, reason :: term, Socket.t()} | {:stop, reason :: term, reply, Socket.t()} @doc """ Intercepts outgoing `event`s. See `intercept/1`. """ @callback handle_out(event :: String.t(), payload :: payload, socket :: Socket.t()) :: {:noreply, Socket.t()} | {:noreply, Socket.t(), timeout | :hibernate} | {:stop, reason :: term, Socket.t()} @doc """ Handle regular Elixir process messages. See `c:GenServer.handle_info/2`. """ @callback handle_info(msg :: term, socket :: Socket.t()) :: {:noreply, Socket.t()} | {:stop, reason :: term, Socket.t()} @doc """ Handle regular GenServer call messages. See `c:GenServer.handle_call/3`. """ @callback handle_call(msg :: term, from :: {pid, tag :: term}, socket :: Socket.t()) :: {:reply, response :: term, Socket.t()} | {:noreply, Socket.t()} | {:stop, reason :: term, Socket.t()} @doc """ Handle regular GenServer cast messages. See `c:GenServer.handle_cast/2`. """ @callback handle_cast(msg :: term, socket :: Socket.t()) :: {:noreply, Socket.t()} | {:stop, reason :: term, Socket.t()} @doc false @callback code_change(old_vsn, Socket.t(), extra :: term) :: {:ok, Socket.t()} | {:error, reason :: term} when old_vsn: term | {:down, term} @doc """ Invoked when the channel process is about to exit. See `c:GenServer.terminate/2`. """ @callback terminate( reason :: :normal | :shutdown | {:shutdown, :left | :closed | term}, Socket.t() ) :: term @optional_callbacks handle_in: 3, handle_out: 3, handle_info: 2, handle_call: 3, handle_cast: 2, code_change: 3, terminate: 2 defmacro __using__(opts \\ []) do quote do opts = unquote(opts) @behaviour unquote(__MODULE__) @on_definition unquote(__MODULE__) @before_compile unquote(__MODULE__) @phoenix_intercepts [] @phoenix_log_join Keyword.get(opts, :log_join, :info) @phoenix_log_handle_in Keyword.get(opts, :log_handle_in, :debug) @phoenix_hibernate_after Keyword.get(opts, :hibernate_after, 15_000) @phoenix_shutdown Keyword.get(opts, :shutdown, 5000) import unquote(__MODULE__) import Phoenix.Socket, only: [assign: 3, assign: 2] def child_spec(init_arg) do %{ id: __MODULE__, start: {__MODULE__, :start_link, [init_arg]}, shutdown: @phoenix_shutdown, restart: :temporary } end def start_link(triplet) do GenServer.start_link(Phoenix.Channel.Server, triplet, hibernate_after: @phoenix_hibernate_after ) end def __socket__(:private) do %{log_join: @phoenix_log_join, log_handle_in: @phoenix_log_handle_in} end end end defmacro __before_compile__(_) do quote do def __intercepts__, do: @phoenix_intercepts end end @doc """ Defines which Channel events to intercept for `handle_out/3` callbacks. By default, broadcasted events are pushed directly to the client, but intercepting events gives your channel a chance to customize the event for the client to append extra information or filter the message from being delivered. *Note*: intercepting events can introduce significantly more overhead if a large number of subscribers must customize a message since the broadcast will be encoded N times instead of a single shared encoding across all subscribers. ## Examples intercept ["new_msg"] def handle_out("new_msg", payload, socket) do push(socket, "new_msg", Map.merge(payload, is_editable: User.can_edit_message?(socket.assigns[:user], payload) )) {:noreply, socket} end `handle_out/3` callbacks must return one of: {:noreply, Socket.t} | {:noreply, Socket.t, timeout | :hibernate} | {:stop, reason :: term, Socket.t} """ defmacro intercept(events) do quote do @phoenix_intercepts unquote(events) end end @doc false def __on_definition__(env, :def, :handle_out, [event, _payload, _socket], _, _) when is_binary(event) do unless event in Module.get_attribute(env.module, :phoenix_intercepts) do IO.write( "#{Path.relative_to(env.file, File.cwd!())}:#{env.line}: [warning] " <> "An intercept for event \"#{event}\" has not yet been defined in #{env.module}.handle_out/3. " <> "Add \"#{event}\" to your list of intercepted events with intercept/1" ) end end def __on_definition__(_env, _kind, _name, _args, _guards, _body) do :ok end @doc """ Broadcast an event to all subscribers of the socket topic. The event's message must be a serializable map or a tagged `{:binary, data}` tuple where `data` is binary data. ## Examples iex> broadcast(socket, "new_message", %{id: 1, content: "hello"}) :ok iex> broadcast(socket, "new_message", {:binary, "hello"}) :ok """ def broadcast(socket, event, message) do %{pubsub_server: pubsub_server, topic: topic} = assert_joined!(socket) Server.broadcast(pubsub_server, topic, event, message) end @doc """ Same as `broadcast/3`, but raises if broadcast fails. """ def broadcast!(socket, event, message) do %{pubsub_server: pubsub_server, topic: topic} = assert_joined!(socket) Server.broadcast!(pubsub_server, topic, event, message) end @doc """ Broadcast event from pid to all subscribers of the socket topic. The channel that owns the socket will not receive the published message. The event's message must be a serializable map or a tagged `{:binary, data}` tuple where `data` is binary data. ## Examples iex> broadcast_from(socket, "new_message", %{id: 1, content: "hello"}) :ok iex> broadcast_from(socket, "new_message", {:binary, "hello"}) :ok """ def broadcast_from(socket, event, message) do %{pubsub_server: pubsub_server, topic: topic, channel_pid: channel_pid} = assert_joined!(socket) Server.broadcast_from(pubsub_server, channel_pid, topic, event, message) end @doc """ Same as `broadcast_from/3`, but raises if broadcast fails. """ def broadcast_from!(socket, event, message) do %{pubsub_server: pubsub_server, topic: topic, channel_pid: channel_pid} = assert_joined!(socket) Server.broadcast_from!(pubsub_server, channel_pid, topic, event, message) end @doc """ Sends an event directly to the connected client without requiring a prior message from the client. The event's message must be a serializable map or a tagged `{:binary, data}` tuple where `data` is binary data. Note that unlike some in client libraries, this server-side `push/3` does not return a reference. If you need to get a reply from the client and to correlate that reply with the message you pushed, you'll need to include a unique identifier in the message, track it in the Channel's state, have the client include it in its reply, and examine the ref when the reply comes to `handle_in/3`. ## Examples iex> push(socket, "new_message", %{id: 1, content: "hello"}) :ok iex> push(socket, "new_message", {:binary, "hello"}) :ok """ def push(socket, event, message) do %{transport_pid: transport_pid, topic: topic} = assert_joined!(socket) Server.push(transport_pid, socket.join_ref, topic, event, message, socket.serializer) end @doc """ Replies asynchronously to a socket push. The usual way of replying to a client's message is to return a tuple from `handle_in/3` like: {:reply, {status, payload}, socket} But sometimes you need to reply to a push asynchronously - that is, after your `handle_in/3` callback completes. For example, you might need to perform work in another process and reply when it's finished. You can do this by generating a reference to the socket with `socket_ref/1` and calling `reply/2` with that ref when you're ready to reply. *Note*: A `socket_ref` is required so the `socket` itself is not leaked outside the channel. The `socket` holds information such as assigns and transport configuration, so it's important to not copy this information outside of the channel that owns it. Technically, `reply/2` will allow you to reply multiple times to the same client message, and each reply will include the client message `ref`. But the client may expect only one reply; in that case, `push/3` would be preferable for the additional messages. Payloads are serialized before sending with the configured serializer. ## Examples def handle_in("work", payload, socket) do Worker.perform(payload, socket_ref(socket)) {:noreply, socket} end def handle_info({:work_complete, result, ref}, socket) do reply(ref, {:ok, result}) {:noreply, socket} end """ @spec reply(socket_ref, reply) :: :ok def reply(socket_ref, status) when is_atom(status) do reply(socket_ref, {status, %{}}) end def reply({transport_pid, serializer, topic, ref, join_ref}, {status, payload}) do Server.reply(transport_pid, join_ref, ref, topic, {status, payload}, serializer) end @doc """ Generates a `socket_ref` for an async reply. See `reply/2` for example usage. """ @spec socket_ref(Socket.t()) :: socket_ref def socket_ref(%Socket{joined: true, ref: ref} = socket) when not is_nil(ref) do {socket.transport_pid, socket.serializer, socket.topic, ref, socket.join_ref} end def socket_ref(_socket) do raise ArgumentError, """ socket refs can only be generated for a socket that has joined with a push ref """ end defp assert_joined!(%Socket{joined: true} = socket) do socket end defp assert_joined!(%Socket{joined: false}) do raise """ push/3, reply/2, and broadcast/3 can only be called after the socket has finished joining. To push a message on join, send to self and handle in handle_info/2. For example: def join(topic, auth_msg, socket) do ... send(self(), :after_join) {:ok, socket} end def handle_info(:after_join, socket) do push(socket, "feed", %{list: feed_items(socket)}) {:noreply, socket} end """ end end ================================================ FILE: lib/phoenix/code_reloader/mix_listener.ex ================================================ defmodule Phoenix.CodeReloader.MixListener do @moduledoc false use GenServer @name __MODULE__ @spec start_link(keyword) :: GenServer.on_start() def start_link(_opts) do GenServer.start_link(__MODULE__, {}, name: @name) end @spec started? :: boolean() def started? do Process.whereis(Phoenix.CodeReloader.MixListener) != nil end @doc """ Unloads all modules invalidated by external compilations. Only reloads modules from the given apps. """ @spec purge([atom()]) :: :ok def purge(apps) do GenServer.call(@name, {:purge, apps}, :infinity) end @impl true def init({}) do {:ok, %{to_purge: %{}}} end @impl true def handle_call({:purge, apps}, _from, state) do for app <- apps, modules = state.to_purge[app] do purge_modules(modules) end {:reply, :ok, %{state | to_purge: %{}}} end @impl true def handle_info({:modules_compiled, info}, state) do if info.os_pid == System.pid() do # Ignore compilations from ourselves, because the modules are # already updated in memory {:noreply, state} else %{changed: changed, removed: removed} = info.modules_diff state = update_in(state.to_purge[info.app], fn to_purge -> to_purge = to_purge || MapSet.new() to_purge = Enum.into(changed, to_purge) Enum.into(removed, to_purge) end) {:noreply, state} end end def handle_info(_message, state) do {:noreply, state} end defp purge_modules(modules) do for module <- modules do :code.purge(module) :code.delete(module) end end end ================================================ FILE: lib/phoenix/code_reloader/proxy.ex ================================================ # A tiny proxy that stores all output sent to the group leader # while forwarding all requests to it. defmodule Phoenix.CodeReloader.Proxy do @moduledoc false use GenServer def start() do GenServer.start(__MODULE__, :ok) end def diagnostics(proxy, diagnostics) do GenServer.cast(proxy, {:diagnostics, diagnostics}) end def stop(proxy) do GenServer.call(proxy, :stop, :infinity) end ## Callbacks def init(:ok) do {:ok, []} end def handle_cast({:diagnostics, diagnostics}, output) do {:noreply, diagnostics |> Enum.map(&diagnostic_to_chars/1) |> Enum.reverse(output)} end def handle_call(:stop, _from, output) do {:stop, :normal, Enum.reverse(output), output} end def handle_info(msg, output) do case msg do {:io_request, from, reply, {:put_chars, chars}} -> put_chars(from, reply, chars, output) {:io_request, from, reply, {:put_chars, m, f, as}} -> put_chars(from, reply, apply(m, f, as), output) {:io_request, from, reply, {:put_chars, _encoding, chars}} -> put_chars(from, reply, chars, output) {:io_request, from, reply, {:put_chars, _encoding, m, f, as}} -> put_chars(from, reply, apply(m, f, as), output) {:io_request, _from, _reply, _request} = msg -> send(Process.group_leader(), msg) {:noreply, output} _ -> {:noreply, output} end end defp put_chars(from, reply, chars, output) do send(Process.group_leader(), {:io_request, from, reply, {:put_chars, chars}}) {:noreply, [chars | output]} end defp diagnostic_to_chars(%{severity: :error, message: "**" <> _ = message}) do "\n#{message}\n" end defp diagnostic_to_chars(%{severity: severity, message: message, file: file, position: position}) when is_binary(file) do "\n#{severity}: #{message}\n #{Path.relative_to_cwd(file)}#{position(position)}\n" end defp diagnostic_to_chars(%{severity: severity, message: message}) do "\n#{severity}: #{message}\n" end defp position({line, col}), do: ":#{line}:#{col}" defp position(line) when is_integer(line) and line > 0, do: ":#{line}" defp position(_), do: "" end ================================================ FILE: lib/phoenix/code_reloader/server.ex ================================================ defmodule Phoenix.CodeReloader.Server do @moduledoc false use GenServer require Logger alias Phoenix.CodeReloader.Proxy def start_link(_) do GenServer.start_link(__MODULE__, :ok, name: __MODULE__) end def check_symlinks do GenServer.call(__MODULE__, :check_symlinks, :infinity) end def reload!(endpoint, opts) do GenServer.call(__MODULE__, {:reload!, endpoint, opts}, :infinity) end def sync do pid = Process.whereis(__MODULE__) ref = Process.monitor(pid) GenServer.cast(pid, {:sync, self(), ref}) receive do ^ref -> :ok {:DOWN, ^ref, _, _, _} -> :ok end end ## Callbacks def init(:ok) do {:ok, %{check_symlinks: true, timestamp: timestamp()}} end def handle_call(:check_symlinks, _from, state) do if state.check_symlinks and Code.ensure_loaded?(Mix.Project) and not Mix.Project.umbrella?() and File.dir?("priv") do priv_path = "#{Mix.Project.app_path()}/priv" case :file.read_link(priv_path) do {:ok, _} -> :ok {:error, _} -> if can_symlink?() do File.rm_rf(priv_path) Mix.Project.build_structure() else Logger.warning( "Phoenix is unable to create symlinks. Phoenix's code reloader will run " <> "considerably faster if symlinks are allowed." <> os_symlink(:os.type()) ) end end end {:reply, :ok, %{state | check_symlinks: false}} end def handle_call({:reload!, endpoint, opts}, from, state) do compilers = endpoint.config(:reloadable_compilers) apps = endpoint.config(:reloadable_apps) || default_reloadable_apps() args = Keyword.get(opts, :reloadable_args, ["--no-all-warnings"]) froms = all_waiting([from], endpoint) {backup, res, out} = with_build_lock(fn -> purge_fallback? = if Phoenix.CodeReloader.MixListener.started?() do Phoenix.CodeReloader.MixListener.purge(apps) false else warn_missing_mix_listener() true end # We do a backup of the endpoint in case compilation fails. # If so we can bring it back to finish the request handling. backup = load_backup(endpoint) {res, out} = proxy_io(fn -> try do task_loaded = Code.ensure_loaded(Mix.Task) mix_compile(task_loaded, compilers, apps, args, state.timestamp, purge_fallback?) catch :exit, {:shutdown, 1} -> :error kind, reason -> IO.puts(Exception.format(kind, reason, __STACKTRACE__)) :error end end) {backup, res, out} end) reply = case res do :ok -> :ok :error -> write_backup(backup) {:error, IO.iodata_to_binary(out)} end Enum.each(froms, &GenServer.reply(&1, reply)) {:noreply, %{state | timestamp: timestamp()}} end def handle_cast({:sync, pid, ref}, state) do send(pid, ref) {:noreply, state} end def handle_info(_, state) do {:noreply, state} end defp default_reloadable_apps() do if Mix.Project.umbrella?() do Enum.map(Mix.Dep.Umbrella.cached(), & &1.app) else [Mix.Project.config()[:app]] end end defp os_symlink({:win32, _}), do: " On Windows, the lack of symlinks may even cause empty assets to be served. " <> "Luckily, you can address this issue by starting your Windows terminal at least " <> "once with \"Run as Administrator\" and then running your Phoenix application." defp os_symlink(_), do: "" defp can_symlink?() do build_path = Mix.Project.build_path() symlink = Path.join(Path.dirname(build_path), "__phoenix__") case File.ln_s(build_path, symlink) do :ok -> File.rm_rf(symlink) true {:error, :eexist} -> File.rm_rf(symlink) true {:error, _} -> false end end defp load_backup(mod) do mod |> :code.which() |> read_backup() end defp read_backup(path) when is_list(path) do case File.read(path) do {:ok, binary} -> {:ok, path, binary} _ -> :error end end defp read_backup(_path), do: :error defp write_backup({:ok, path, file}), do: File.write!(path, file) defp write_backup(:error), do: :ok defp all_waiting(acc, endpoint) do receive do {:"$gen_call", from, {:reload!, ^endpoint, _}} -> all_waiting([from | acc], endpoint) after 0 -> acc end end if Version.match?(System.version(), ">= 1.18.0-dev") do defp warn_missing_mix_listener do if Mix.Project.get() != Phoenix.MixProject do IO.warn(""" a Mix listener expected by Phoenix.CodeReloader is missing. Please add the listener to your mix.exs configuration, like so: def project do [ ..., listeners: [Phoenix.CodeReloader] ] end """) end end else defp warn_missing_mix_listener do :ok end end defp mix_compile( {:module, Mix.Task}, compilers, apps_to_reload, compile_args, timestamp, purge_fallback? ) do config = Mix.Project.config() path = Mix.Project.consolidation_path(config) mix_compile_deps( Mix.Dep.cached(), apps_to_reload, compile_args, compilers, timestamp, path, purge_fallback? ) mix_compile_project( config[:app], apps_to_reload, compile_args, compilers, timestamp, path, purge_fallback? ) if config[:consolidate_protocols] do # If we are consolidating protocols, we need to purge all of its modules # to ensure the consolidated versions are loaded. "mix compile" performs # a similar task. Code.prepend_path(path) purge_modules(path) end :ok end defp mix_compile({:error, _reason}, _, _, _, _, _) do raise "the Code Reloader is enabled but Mix is not available. If you want to " <> "use the Code Reloader in production or inside an escript, you must add " <> ":mix to your applications list. Otherwise, you must disable code reloading " <> "in such environments" end defp mix_compile_deps( deps, apps_to_reload, compile_args, compilers, timestamp, path, purge_fallback? ) do for dep <- deps, dep.app in apps_to_reload do Mix.Dep.in_dependency(dep, fn _ -> mix_compile_unless_stale_config(compilers, compile_args, timestamp, path, purge_fallback?) end) end end defp mix_compile_project(nil, _, _, _, _, _, _), do: :ok defp mix_compile_project( app, apps_to_reload, compile_args, compilers, timestamp, path, purge_fallback? ) do if app in apps_to_reload do mix_compile_unless_stale_config(compilers, compile_args, timestamp, path, purge_fallback?) end end defp mix_compile_unless_stale_config(compilers, compile_args, timestamp, path, purge_fallback?) do manifests = Mix.Tasks.Compile.Elixir.manifests() configs = Mix.Project.config_files() config = Mix.Project.config() case Mix.Utils.extract_stale(configs, manifests) do [] -> # If the manifests are more recent than the timestamp, # someone updated this app behind the scenes, so purge all beams. # TODO: remove once we depend on Elixir 1.18 if purge_fallback? and Mix.Utils.stale?(manifests, [timestamp]) do purge_modules(Path.join(Mix.Project.app_path(config), "ebin")) end mix_compile(compilers, compile_args, config, path) files -> raise """ could not compile application: #{Mix.Project.config()[:app]}. You must restart your server after changing configuration files or your dependencies. In particular, the following files changed and must be recomputed on a server restart: * #{Enum.map_join(files, "\n * ", &Path.relative_to_cwd/1)} """ end end defp mix_compile(compilers, compile_args, config, consolidation_path) do all = config[:compilers] || Mix.compilers() compilers = for compiler <- compilers, compiler in all do Mix.Task.reenable("compile.#{compiler}") compiler end # We call build_structure mostly for Windows so new # assets in priv are copied to the build directory. Mix.Project.build_structure(config) args = [ # TODO: The purge option may no longer be required from Elixir v1.18 "--purge-consolidation-path-if-stale", consolidation_path, # Since Elixir v1.20, Elixir no longer automatically purges compiler # modules, which is ok for most workflows, but since code reloading never # shuts down the server, we enable purging to avoid too many temp modules. "--purge-compiler-modules" | compile_args ] {status, diagnostics} = with_logger_app(config, fn -> run_compilers(compilers, args, :noop, []) end) Proxy.diagnostics(Process.group_leader(), diagnostics) cond do status == :error -> if "--return-errors" not in args do exit({:shutdown, 1}) end status == :ok && config[:consolidate_protocols] -> # TODO: Calling compile.protocols is no longer be required from Elixir v1.19 Mix.Task.reenable("compile.protocols") Mix.Task.run("compile.protocols", []) :ok true -> :ok end end defp timestamp, do: System.system_time(:second) defp purge_modules(path) do with {:ok, beams} <- File.ls(path) do for beam <- beams do case :binary.split(beam, ".beam") do [module, ""] -> module |> String.to_atom() |> purge_module() _ -> :ok end end :ok end end defp purge_module(module) do :code.purge(module) :code.delete(module) end defp proxy_io(fun) do original_gl = Process.group_leader() {:ok, proxy_gl} = Proxy.start() Process.group_leader(self(), proxy_gl) try do {fun.(), Proxy.stop(proxy_gl)} after Process.group_leader(self(), original_gl) Process.exit(proxy_gl, :kill) end end ## TODO: Replace this by Mix.Task.Compiler.run/2 on Elixir v1.19+ defp run_compilers([], _, status, diagnostics) do {status, diagnostics} end defp run_compilers([compiler | rest], args, status, diagnostics) do {new_status, new_diagnostics} = run_compiler(compiler, args) diagnostics = diagnostics ++ new_diagnostics case new_status do :error -> {:error, diagnostics} :ok -> run_compilers(rest, args, :ok, diagnostics) :noop -> run_compilers(rest, args, status, diagnostics) end end defp run_compiler(compiler, args) do result = normalize(Mix.Task.run("compile.#{compiler}", args), compiler) Enum.reduce(Mix.ProjectStack.pop_after_compiler(compiler), result, & &1.(&2)) end defp normalize(result, name) do case result do {status, diagnostics} when status in [:ok, :noop, :error] and is_list(diagnostics) -> {status, diagnostics} # ok/noop can come from tasks that have already run _ when result in [:ok, :noop] -> {result, []} _ -> # TODO: Convert this to an error on v2.0 Mix.shell().error( "warning: Mix compiler #{inspect(name)} was supposed to return " <> "{:ok | :noop | :error, [diagnostic]} but it returned #{inspect(result)}" ) {:noop, []} end end # TODO: remove once we depend on Elixir 1.17 defp with_logger_app(config, fun) do app = Keyword.fetch!(config, :app) logger_config_app = Application.get_env(:logger, :compile_time_application) try do Logger.configure(compile_time_application: app) fun.() after Logger.configure(compile_time_application: logger_config_app) end end # TODO: remove once we depend on Elixir 1.18 if Code.ensure_loaded?(Mix.Project) and function_exported?(Mix.Project, :with_build_lock, 1) do defp with_build_lock(fun), do: Mix.Project.with_build_lock(fun) else defp with_build_lock(fun), do: fun.() end end ================================================ FILE: lib/phoenix/code_reloader.ex ================================================ defmodule Phoenix.CodeReloader do @moduledoc """ A plug and module to handle automatic code reloading. To avoid race conditions, all code reloads are funneled through a sequential call operation. """ ## Server delegation @doc """ Reloads code for the current Mix project by invoking the `:reloadable_compilers` on the list of `:reloadable_apps`. This is configured in your application environment like: config :your_app, YourAppWeb.Endpoint, reloadable_compilers: [:gettext, :elixir], reloadable_apps: [:ui, :backend] Keep in mind `:reloadable_compilers` must be a subset of the `:compilers` specified in `project/0` in your `mix.exs`. The `:reloadable_apps` defaults to `nil`. In such case default behaviour is to reload the current project if it consists of a single app, or all applications within an umbrella project. You can set `:reloadable_apps` to a subset of default applications to reload only some of them, an empty list - to effectively disable the code reloader, or include external applications from library dependencies. This function is a no-op and returns `:ok` if Mix is not available. The reloader should also be configured as a Mix listener in project's mix.exs file (since Elixir v1.18): def project do [ ..., listeners: [Phoenix.CodeReloader] ] end This way the reloader can notice whenever the project is compiled concurrently. ## Options * `:reloadable_args` - additional CLI args to pass to the compiler tasks. Defaults to `["--no-all-warnings"]` so only warnings related to the files being compiled are printed """ @spec reload(module, keyword) :: :ok | {:error, binary()} def reload(endpoint, opts \\ []) do if Code.ensure_loaded?(Mix.Project), do: reload!(endpoint, opts), else: :ok end @doc """ Same as `reload/1` but it will raise if Mix is not available. """ @spec reload!(module, keyword) :: :ok | {:error, binary()} defdelegate reload!(endpoint, opts), to: Phoenix.CodeReloader.Server @doc """ Synchronizes with the code server if it is alive. It returns `:ok`. If it is not running, it also returns `:ok`. """ @spec sync :: :ok defdelegate sync, to: Phoenix.CodeReloader.Server @doc false @spec child_spec(keyword) :: Supervisor.child_spec() defdelegate child_spec(opts), to: Phoenix.CodeReloader.MixListener ## Plug @behaviour Plug import Plug.Conn @style %{ light: %{ primary: "#EB532D", accent: "#a0b0c0", text_color: "#304050", background: "#ffffff", heading_background: "#f9f9fa" }, dark: %{ primary: "#FF6B4A", accent: "#c0c0c0", text_color: "#e5e5e5", background: "#1a1a1a", heading_background: "#2a2a2a" }, logo: "data:image/svg+xml;base64,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", monospace_font: "menlo, consolas, monospace" } @doc """ API used by Plug to start the code reloader. """ def init(opts) do Keyword.put_new(opts, :reloader, &Phoenix.CodeReloader.reload/2) end @doc """ API used by Plug to invoke the code reloader on every request. """ def call(conn, opts) do case opts[:reloader].(conn.private.phoenix_endpoint, opts) do :ok -> conn {:error, output} -> conn |> put_resp_content_type("text/html") |> send_resp(500, template(output)) |> halt() end end defp template(output) do """ CompileError
Compilation error
Console output is shown below.
#{format_output(output)}
""" end defp format_output(output) do output |> String.trim() |> remove_ansi_escapes() |> Plug.HTML.html_escape() end defp remove_ansi_escapes(text) do Regex.replace(~r/\e\[[0-9;]*[a-zA-Z]/, text, "") end end ================================================ FILE: lib/phoenix/config.ex ================================================ defmodule Phoenix.Config do # Handles Phoenix configuration. # # This module is private to Phoenix and should not be accessed # directly. The Phoenix endpoint configuration can be accessed # at runtime using the `config/2` function. @moduledoc false use GenServer @doc """ Starts a Phoenix configuration handler. """ def start_link({module, config, defaults, opts}) do permanent = Keyword.keys(defaults) GenServer.start_link(__MODULE__, {module, config, permanent}, opts) end @doc """ Puts a given key-value pair in config. """ def put(module, key, value) do :ets.insert(module, {key, value}) end @doc """ Adds permanent configuration. Permanent configuration is not deleted on hot code reload. """ def permanent(module, key, value) do pid = :ets.lookup_element(module, :__config__, 2) GenServer.call(pid, {:permanent, key, value}) end @doc """ Caches a value in Phoenix configuration handler for the module. The given function needs to return a tuple with `:cache` if the value should be cached or `:nocache` if the value should not be cached because it can be consequently considered stale. Notice writes are not serialized to the server, we expect the function that generates the cache to be idempotent. """ @spec cache(module, term, (module -> {:cache | :nocache, term})) :: term def cache(module, key, fun) do try do :ets.lookup(module, key) rescue e -> case :ets.info(module) do :undefined -> raise "could not find ets table for endpoint #{inspect(module)}. Make sure your endpoint is started and note you cannot access endpoint functions at compile-time" _ -> reraise e, __STACKTRACE__ end else [{^key, :cache, val}] -> val [] -> case fun.(module) do {:cache, val} -> :ets.insert(module, {key, :cache, val}) val {:nocache, val} -> val end end end @doc """ Clears all cached entries in the endpoint. """ @spec clear_cache(module) :: :ok def clear_cache(module) do :ets.match_delete(module, {:_, :cache, :_}) :ok end @doc """ Reads the configuration for module from the given OTP app. Useful to read a particular value at compilation time. """ def from_env(otp_app, module, defaults) do config = fetch_config(otp_app, module) merge(defaults, config) end defp fetch_config(otp_app, module) do case Application.fetch_env(otp_app, module) do {:ok, conf} -> conf :error -> [] end end @doc """ Take 2 keyword lists and merge them recursively. Used to merge configuration values into defaults. """ def merge(a, b), do: Keyword.merge(a, b, &merger/3) defp merger(_k, v1, v2) do if Keyword.keyword?(v1) and Keyword.keyword?(v2) do Keyword.merge(v1, v2, &merger/3) else v2 end end @doc """ Changes the configuration for the given module. It receives a keyword list with changed config and another with removed ones. The changed config are updated while the removed ones stop the configuration server, effectively removing the table. """ def config_change(module, changed, removed) do pid = :ets.lookup_element(module, :__config__, 2) GenServer.call(pid, {:config_change, changed, removed}) end # Callbacks def init({module, config, permanent}) do :ets.new(module, [:named_table, :public, read_concurrency: true]) update(module, config, []) :ets.insert(module, {:__config__, self()}) {:ok, {module, [:__config__ | permanent]}} end def handle_call({:permanent, key, value}, _from, {module, permanent}) do :ets.insert(module, {key, value}) {:reply, :ok, {module, [key | permanent]}} end def handle_call({:config_change, changed, removed}, _from, {module, permanent}) do cond do changed = changed[module] -> update(module, changed, permanent) {:reply, :ok, {module, permanent}} module in removed -> {:stop, :normal, :ok, {module, permanent}} true -> clear_cache(module) {:reply, :ok, {module, permanent}} end end defp update(module, config, permanent) do old_keys = :ets.select(module, [{{:"$1", :_}, [], [:"$1"]}]) new_keys = Enum.map(config, &elem(&1, 0)) Enum.each((old_keys -- new_keys) -- permanent, &:ets.delete(module, &1)) :ets.insert(module, config) clear_cache(module) end end ================================================ FILE: lib/phoenix/controller/pipeline.ex ================================================ defmodule Phoenix.Controller.Pipeline do @moduledoc false @doc false defmacro __using__(_) do quote do @behaviour Plug require Phoenix.Endpoint import Phoenix.Controller.Pipeline Module.register_attribute(__MODULE__, :plugs, accumulate: true) @before_compile Phoenix.Controller.Pipeline @phoenix_fallback :unregistered @doc false def init(opts), do: opts @doc false def call(conn, action) when is_atom(action) do conn |> merge_private( phoenix_controller: __MODULE__, phoenix_action: action ) |> phoenix_controller_pipeline(action) end @doc false def action(%Plug.Conn{private: %{phoenix_action: action}} = conn, _options) do apply(__MODULE__, action, [conn, conn.params]) end defoverridable init: 1, call: 2, action: 2 end end @doc false def __action_fallback__(plug, caller) do plug = Macro.expand(plug, %{caller | function: {:init, 1}}) quote bind_quoted: [plug: plug] do @phoenix_fallback Phoenix.Controller.Pipeline.validate_fallback( plug, __MODULE__, Module.get_attribute(__MODULE__, :phoenix_fallback) ) end end @doc false def validate_fallback(plug, module, fallback) do cond do fallback == nil -> raise """ action_fallback can only be called when using Phoenix.Controller. Add `use Phoenix.Controller` to #{inspect(module)} """ fallback != :unregistered -> raise "action_fallback can only be called a single time per controller." not is_atom(plug) -> raise ArgumentError, "expected action_fallback to be a module or function plug, got #{inspect(plug)}" fallback == :unregistered -> case Atom.to_charlist(plug) do ~c"Elixir." ++ _ -> {:module, plug} _ -> {:function, plug} end end end @doc false defmacro __before_compile__(env) do action = {:action, [], true} plugs = [action | Module.get_attribute(env.module, :plugs)] {conn, body} = Plug.Builder.compile(env, plugs, log_on_halt: :debug, init_mode: Phoenix.plug_init_mode() ) fallback_ast = env.module |> Module.get_attribute(:phoenix_fallback) |> build_fallback() quote do defoverridable action: 2 def action(var!(conn_before), opts) do try do var!(conn_after) = super(var!(conn_before), opts) unquote(fallback_ast) catch :error, reason -> Phoenix.Controller.Pipeline.__catch__( var!(conn_before), reason, __MODULE__, var!(conn_before).private.phoenix_action, __STACKTRACE__ ) end end defp phoenix_controller_pipeline(unquote(conn), var!(action)) do var!(conn) = unquote(conn) var!(controller) = __MODULE__ _ = var!(conn) _ = var!(controller) _ = var!(action) unquote(body) end end end defp build_fallback(:unregistered) do quote do: var!(conn_after) end defp build_fallback({:module, plug}) do quote bind_quoted: binding() do case var!(conn_after) do %Plug.Conn{} = conn_after -> conn_after val -> plug.call(var!(conn_before), plug.init(val)) end end end defp build_fallback({:function, plug}) do quote do case var!(conn_after) do %Plug.Conn{} = conn_after -> conn_after val -> unquote(plug)(var!(conn_before), val) end end end @doc false def __catch__( %Plug.Conn{}, :function_clause, controller, action, [{controller, action, [%Plug.Conn{} | _] = action_args, _loc} | _] = stack ) do args = [module: controller, function: action, arity: length(action_args), args: action_args] reraise Phoenix.ActionClauseError, args, stack end def __catch__(%Plug.Conn{} = conn, reason, _controller, _action, stack) do Plug.Conn.WrapperError.reraise(conn, :error, reason, stack) end @doc """ Stores a plug to be executed as part of the plug pipeline. """ defmacro plug(plug) defmacro plug({:when, _, [plug, guards]}), do: plug(plug, [], guards, __CALLER__) defmacro plug(plug), do: plug(plug, [], true, __CALLER__) @doc """ Stores a plug with the given options to be executed as part of the plug pipeline. """ defmacro plug(plug, opts) defmacro plug(plug, {:when, _, [opts, guards]}), do: plug(plug, opts, guards, __CALLER__) defmacro plug(plug, opts), do: plug(plug, opts, true, __CALLER__) defp plug(plug, opts, guards, caller) do runtime? = Phoenix.plug_init_mode() == :runtime plug = if runtime? do expand_alias(plug, caller) else plug end opts = if runtime? and Macro.quoted_literal?(opts) do Macro.prewalk(opts, &expand_alias(&1, caller)) else opts end quote do @plugs {unquote(plug), unquote(opts), unquote(escape_guards(guards))} end end defp expand_alias({:__aliases__, _, _} = alias, env), do: Macro.expand(alias, %{env | function: {:init, 1}}) defp expand_alias(other, _env), do: other defp escape_guards({pre_expanded, _, [_ | _]} = node) when pre_expanded in [:@, :__aliases__], do: node defp escape_guards({left, meta, right}), do: {:{}, [], [escape_guards(left), meta, escape_guards(right)]} defp escape_guards({left, right}), do: {escape_guards(left), escape_guards(right)} defp escape_guards([_ | _] = list), do: Enum.map(list, &escape_guards/1) defp escape_guards(node), do: node end ================================================ FILE: lib/phoenix/controller.ex ================================================ defmodule Phoenix.Controller do import Plug.Conn alias Plug.Conn.AlreadySentError require Logger @unsent [:unset, :set, :set_chunked, :set_file] # View/Layout deprecation plan # 1. DONE! Deprecate :namespace option in favor of :layouts on use # 2. Deprecate the :layouts option in use Phoenix.Controller # 3. Deprecate setting a non-format view/layout on put_* # 4. Deprecate rendering a view/layout from :_ @type view :: atom() @type layout :: {module(), layout_name :: atom()} | false @moduledoc """ Controllers are used to group common functionality in the same (pluggable) module. For example, the route: get "/users/:id", MyAppWeb.UserController, :show will invoke the `show/2` action in the `MyAppWeb.UserController`: defmodule MyAppWeb.UserController do use MyAppWeb, :controller def show(conn, %{"id" => id}) do user = Repo.get(User, id) render(conn, :show, user: user) end end An action is a regular function that receives the connection and the request parameters as arguments. The connection is a `Plug.Conn` struct, as specified by the Plug library. Then we invoke `render/3`, passing the connection, the template to render (typically named after the action), and the `user: user` as assigns. We will explore all of those concepts next. ## Connection A controller by default provides many convenience functions for manipulating the connection, rendering templates, and more. Those functions are imported from two modules: * `Plug.Conn` - a collection of low-level functions to work with the connection * `Phoenix.Controller` - functions provided by Phoenix to support rendering, and other Phoenix specific behaviour If you want to have functions that manipulate the connection without fully implementing the controller, you can import both modules directly instead of `use Phoenix.Controller`. ## Rendering One of the main features provided by controllers is the ability to perform content negotiation and render templates based on information sent by the client. There are two ways to render content in a controller. One option is to invoke format-specific functions, such as `html/2` and `json/2`. However, most commonly controllers invoke custom modules called views. Views are modules capable of rendering a custom format. This is done by specifying the option `:formats` when defining the controller: use Phoenix.Controller, formats: [:html, :json] Now, when invoking `render/3`, a controller named `MyAppWeb.UserController` will invoke `MyAppWeb.UserHTML` and `MyAppWeb.UserJSON` respectively when rendering each format: def show(conn, %{"id" => id}) do user = Repo.get(User, id) # Will invoke UserHTML.show(%{user: user}) for html requests # Will invoke UserJSON.show(%{user: user}) for json requests render(conn, :show, user: user) end You can also specify formats to render by calling `put_view/2` directly with a connection. For example, instead of inferring the the view names from the controller, as done in: use Phoenix.Controller, formats: [:html, :json] You can write the above explicitly in your actions as: put_view(conn, html: MyAppWeb.UserHTML, json: MyAppWeb.UserJSON) Or as a plug: plug :put_view, html: MyAppWeb.UserHTML, json: MyAppWeb.UserJSON ## Layouts Many applications have shared content that they want to include on every page, most often the `` tag and its contents. In Phoenix, this is done via the `put_root_layout` function: put_root_layout(conn, html: {MyAppWeb.Layouts, :root}) In most applications, this is invoked as a Plug in your application router: plug :put_root_layout, html: {MyAppWeb.Layouts, :root} This layout is shared by all controllers, and also by `Phoenix.LiveView`. However, you can also specify controller-specific layouts using `put_layout/2`, although this functionality is discouraged in Phoenix v1.8 in favor of using function components to build your application. ## Options When used, the controller supports the following options to customize template rendering: * `:formats` - the formats this controller will render by default. For example, specifying `formats: [:html, :json]` for a controller named `MyAppWeb.UserController` will invoke `MyAppWeb.UserHTML` and `MyAppWeb.UserJSON` when respectively rendering each format. The `:formats` option is required. You may set it to an empty list if you don't expect to render any format upfront. To retain the behaviour of older Phoenix versions, you can explicitly pass the "View" suffix to the `:formats` option: use Phoenix.Controller, formats: [html: "View", json: "View"] ## Plug pipeline As with routers, controllers also have their own plug pipeline. However, different from routers, controllers have a single pipeline: defmodule MyAppWeb.UserController do use MyAppWeb, :controller plug :authenticate, usernames: ["jose", "eric", "sonny"] def show(conn, params) do # authenticated users only end defp authenticate(conn, options) do if get_session(conn, :username) in options[:usernames] do conn else conn |> redirect(to: "/") |> halt() end end end The `:authenticate` plug will be invoked before the action. If the plug calls `Plug.Conn.halt/1` (which is by default imported into controllers), it will halt the pipeline and won't invoke the action. ### Guards `plug/2` in controllers supports guards, allowing a developer to configure a plug to only run in some particular action. plug :do_something when action in [:show, :edit] Due to operator precedence in Elixir, if the second argument is a keyword list, we need to wrap the keyword in `[...]` when using `when`: plug :authenticate, [usernames: ["jose", "eric", "sonny"]] when action in [:show, :edit] plug :authenticate, [usernames: ["admin"]] when not action in [:index] The first plug will run only when action is show or edit. The second plug will always run, except for the index action. Those guards work like regular Elixir guards and the only variables accessible in the guard are `conn`, the `action` as an atom and the `controller` as an alias. ## Controllers are plugs Like routers, controllers are plugs, but they are wired to dispatch to a particular function which is called an action. For example, the route: get "/users/:id", UserController, :show will invoke `UserController` as a plug: UserController.call(conn, :show) which will trigger the plug pipeline and which will eventually invoke the inner action plug that dispatches to the `show/2` function in `UserController`. As controllers are plugs, they implement both [`init/1`](`c:Plug.init/1`) and [`call/2`](`c:Plug.call/2`), and it also provides a function named `action/2` which is responsible for dispatching the appropriate action after the plug stack (and is also overridable). ### Overriding `action/2` for custom arguments Phoenix injects an `action/2` plug in your controller which calls the function matched from the router. By default, it passes the conn and params. In some cases, overriding the `action/2` plug in your controller is a useful way to inject arguments into your actions that you would otherwise need to repeatedly fetch off the connection. For example, imagine if you stored a `conn.assigns.current_user` in the connection and wanted quick access to the user for every action in your controller: def action(conn, _) do args = [conn, conn.params, conn.assigns.current_user] apply(__MODULE__, action_name(conn), args) end def index(conn, _params, user) do videos = Repo.all(user_videos(user)) # ... end def delete(conn, %{"id" => id}, user) do video = Repo.get!(user_videos(user), id) # ... end """ defmacro __using__(opts) do opts = if Macro.quoted_literal?(opts) do Macro.prewalk(opts, &expand_alias(&1, __CALLER__)) else opts end quote bind_quoted: [opts: opts] do import Phoenix.Controller import Plug.Conn use Phoenix.Controller.Pipeline with {layout, view} <- Phoenix.Controller.__plugs__(__MODULE__, opts) do plug :put_new_layout, layout plug :put_new_view, view end end end defp expand_alias({:__aliases__, _, _} = alias, env), do: Macro.expand(alias, %{env | function: {:action, 2}}) defp expand_alias(other, _env), do: other @doc """ Registers the plug to call as a fallback to the controller action. A fallback plug is useful to translate common domain data structures into a valid `%Plug.Conn{}` response. If the controller action fails to return a `%Plug.Conn{}`, the provided plug will be called and receive the controller's `%Plug.Conn{}` as it was before the action was invoked along with the value returned from the controller action. ## Examples defmodule MyController do use Phoenix.Controller action_fallback MyFallbackController def show(conn, %{"id" => id}, current_user) do with {:ok, post} <- Blog.fetch_post(id), :ok <- Authorizer.authorize(current_user, :view, post) do render(conn, "show.json", post: post) end end end In the above example, `with` is used to match only a successful post fetch, followed by valid authorization for the current user. In the event either of those fail to match, `with` will not invoke the render block and instead return the unmatched value. In this case, imagine `Blog.fetch_post/2` returned `{:error, :not_found}` or `Authorizer.authorize/3` returned `{:error, :unauthorized}`. For cases where these data structures serve as return values across multiple boundaries in our domain, a single fallback module can be used to translate the value into a valid response. For example, you could write the following fallback controller to handle the above values: defmodule MyFallbackController do use Phoenix.Controller def call(conn, {:error, :not_found}) do conn |> put_status(:not_found) |> put_view(MyErrorView) |> render(:"404") end def call(conn, {:error, :unauthorized}) do conn |> put_status(:forbidden) |> put_view(MyErrorView) |> render(:"403") end end """ defmacro action_fallback(plug) do Phoenix.Controller.Pipeline.__action_fallback__(plug, __CALLER__) end @doc """ Returns the action name as an atom, raises if unavailable. """ @spec action_name(Plug.Conn.t()) :: atom def action_name(conn), do: conn.private.phoenix_action @doc """ Returns the controller module as an atom, raises if unavailable. """ @spec controller_module(Plug.Conn.t()) :: atom def controller_module(conn), do: conn.private.phoenix_controller @doc """ Returns the router module as an atom, raises if unavailable. """ @spec router_module(Plug.Conn.t()) :: atom def router_module(conn), do: conn.private.phoenix_router @doc """ Returns the endpoint module as an atom, raises if unavailable. """ @spec endpoint_module(Plug.Conn.t()) :: atom def endpoint_module(conn), do: conn.private.phoenix_endpoint @doc """ Returns the template name rendered in the view as a string (or nil if no template was rendered). """ @spec view_template(Plug.Conn.t()) :: binary | nil def view_template(conn) do conn.private[:phoenix_template] end @doc """ Sends JSON response. It uses the configured `:json_library` under the `:phoenix` application for `:json` to pick up the encoder module. ## Examples iex> json(conn, %{id: 123}) """ @spec json(Plug.Conn.t(), term) :: Plug.Conn.t() def json(conn, data) do response = Phoenix.json_library().encode_to_iodata!(data) send_resp(conn, conn.status || 200, "application/json", response) end @doc """ A plug that may convert a JSON response into a JSONP one. In case a JSON response is returned, it will be converted to a JSONP as long as the callback field is present in the query string. The callback field itself defaults to "callback", but may be configured with the callback option. In case there is no callback or the response is not encoded in JSON format, it is a no-op. Only alphanumeric characters and underscore are allowed in the callback name. Otherwise an exception is raised. ## Examples # Will convert JSON to JSONP if callback=someFunction is given plug :allow_jsonp # Will convert JSON to JSONP if cb=someFunction is given plug :allow_jsonp, callback: "cb" """ @spec allow_jsonp(Plug.Conn.t(), Keyword.t()) :: Plug.Conn.t() def allow_jsonp(conn, opts \\ []) do callback = Keyword.get(opts, :callback, "callback") case Map.fetch(conn.query_params, callback) do :error -> conn {:ok, ""} -> conn {:ok, cb} -> validate_jsonp_callback!(cb) register_before_send(conn, fn conn -> if json_response?(conn) do conn |> put_resp_header("content-type", "application/javascript") |> resp(conn.status, jsonp_body(conn.resp_body, cb)) else conn end end) end end defp json_response?(conn) do case get_resp_header(conn, "content-type") do ["application/json;" <> _] -> true ["application/json"] -> true _ -> false end end defp jsonp_body(data, callback) do body = data |> IO.iodata_to_binary() |> String.replace(<<0x2028::utf8>>, "\\u2028") |> String.replace(<<0x2029::utf8>>, "\\u2029") "/**/ typeof #{callback} === 'function' && #{callback}(#{body});" end defp validate_jsonp_callback!(<>) when h in ?0..?9 or h in ?A..?Z or h in ?a..?z or h == ?_, do: validate_jsonp_callback!(t) defp validate_jsonp_callback!(<<>>), do: :ok defp validate_jsonp_callback!(_), do: raise(ArgumentError, "the JSONP callback name contains invalid characters") @doc """ Sends text response. ## Examples iex> text(conn, "hello") iex> text(conn, :implements_to_string) """ @spec text(Plug.Conn.t(), String.Chars.t()) :: Plug.Conn.t() def text(conn, data) do send_resp(conn, conn.status || 200, "text/plain", to_string(data)) end @doc """ Sends html response. ## Examples iex> html(conn, "...") """ @spec html(Plug.Conn.t(), iodata) :: Plug.Conn.t() def html(conn, data) do send_resp(conn, conn.status || 200, "text/html", data) end @doc """ Sends redirect response to the given url. For security, `:to` only accepts paths. Use the `:external` option to redirect to any URL. The response will be sent with the status code defined within the connection, via `Plug.Conn.put_status/2`. If no status code is set, a 302 response is sent. ## Examples iex> redirect(conn, to: "/login") iex> redirect(conn, external: "https://elixir-lang.org") """ def redirect(conn, opts) when is_list(opts) do url = url(opts) html = Plug.HTML.html_escape(url) body = "You are being redirected." conn |> put_resp_header("location", url) |> send_resp(conn.status || 302, "text/html", body) end defp url(opts) do cond do to = opts[:to] -> validate_local_url(to) external = opts[:external] -> external true -> raise ArgumentError, "expected :to or :external option in redirect/2" end end @invalid_local_url_chars ["\\", "/%09", "/\t"] defp validate_local_url("//" <> _ = to), do: raise_invalid_url(to) defp validate_local_url("/" <> _ = to) do if String.contains?(to, @invalid_local_url_chars) do raise ArgumentError, "unsafe characters detected for local redirect in URL #{inspect(to)}" else to end end defp validate_local_url(to), do: raise_invalid_url(to) @spec raise_invalid_url(term()) :: no_return() defp raise_invalid_url(url) do raise ArgumentError, "the :to option in redirect expects a path but was #{inspect(url)}" end @doc """ Stores the view for rendering. Raises `Plug.Conn.AlreadySentError` if `conn` is already sent. ## Examples iex> put_view(conn, html: AppHTML, json: AppJSON) """ @spec put_view(Plug.Conn.t(), [{format :: atom, view}] | view) :: Plug.Conn.t() def put_view(%Plug.Conn{state: state} = conn, formats) when state in @unsent do put_private_view(conn, :phoenix_view, :replace, formats) end def put_view(%Plug.Conn{} = conn, module) do raise(AlreadySentError, """ the response was already sent. Status code: #{conn.status} Request path: #{conn.request_path} Method: #{conn.method} View module: #{inspect(module)} """) end defp put_private_view(conn, priv_key, kind, formats) when is_list(formats) do formats = Enum.into(formats, %{}, fn {format, value} -> {to_string(format), value} end) put_private_formats(conn, priv_key, kind, formats) end # TODO: Deprecate this whole branch on Phoenix v1.9 defp put_private_view(conn, priv_key, kind, value) do put_private_formats(conn, priv_key, kind, %{_: value}) end defp put_private_formats(conn, priv_key, kind, formats) when kind in [:new, :replace] do update_in(conn.private, fn private -> existing = Map.get(private, priv_key, %{}) new_formats = case kind do :new -> Map.merge(formats, existing) :replace -> Map.merge(existing, formats) end Map.put(private, priv_key, new_formats) end) end @doc """ Stores the view for rendering if one was not stored yet. Raises `Plug.Conn.AlreadySentError` if `conn` is already sent. """ # TODO: Remove | view from the spec once we deprecate put_new_view on controllers on v1.9 @spec put_new_view(Plug.Conn.t(), [{format :: atom, view}] | view) :: Plug.Conn.t() def put_new_view(%Plug.Conn{state: state} = conn, formats) when state in @unsent do put_private_view(conn, :phoenix_view, :new, formats) end def put_new_view(%Plug.Conn{} = conn, module) do raise(AlreadySentError, """ the response was already sent. Status code: #{conn.status} Request path: #{conn.request_path} Method: #{conn.method} View module: #{inspect(module)} """) end @doc """ Retrieves the current view for the given format. If no format is given, takes the current one from the connection. """ @spec view_module(Plug.Conn.t(), binary | nil) :: atom def view_module(conn, format \\ nil) do format = format || get_safe_format(conn) # TODO: Remove the first branch once code paths are deprecated and then removed case conn.private[:phoenix_view] do %{_: value} when value != nil -> value %{^format => value} -> value formats -> raise "no view was found for the format: #{inspect(format)}. " <> "The supported formats are: #{inspect(Map.keys(formats || %{}) -- [:_])}" end end @doc """ Stores the layout for rendering. The layout must be given as keyword list where the key is the request format the layout will be applied to (such as `:html`) and the value is one of: * `{module, layout}` with the `module` the layout is defined and the name of the `layout` as an atom * `false` which disables the layout If `false` is given without a format, all layouts are disabled. ## Examples iex> layout(conn) false iex> conn = put_layout(conn, html: {AppView, :application}) iex> layout(conn) {AppView, :application} iex> conn = put_layout(conn, html: {AppView, :print}) iex> layout(conn) {AppView, :print} Raises `Plug.Conn.AlreadySentError` if `conn` is already sent. """ @spec put_layout(Plug.Conn.t(), [{format :: atom, layout}] | false) :: Plug.Conn.t() def put_layout(%Plug.Conn{state: state} = conn, layout) do if state in @unsent do put_private_layout(conn, :phoenix_layout, :replace, layout) else raise AlreadySentError, """ the response was already sent. Status code: #{conn.status} Request path: #{conn.request_path} Method: #{conn.method} Layout: #{inspect(layout)} """ end end defp put_private_layout(conn, private_key, kind, layouts) when is_list(layouts) do formats = Map.new(layouts, fn {format, false} -> {Atom.to_string(format), false} {format, layout} when is_atom(layout) -> format = Atom.to_string(format) case conn.private[private_key] do %{^format => {mod, _}} -> IO.warn(""" specifying a layout without module is deprecated, use #{format}: #{inspect({mod, layout})} instead\ """) {format, {mod, layout}} %{} -> raise "cannot use put_layout/2 or put_root_layout/2 with atom because " <> "there is no previous layout set for format #{inspect(format)}" end {format, {mod, layout}} when is_atom(mod) and is_atom(layout) -> {Atom.to_string(format), {mod, layout}} {format, other} -> raise ArgumentError, """ put_layout and put_root_layout expects an module and template per format, such as: #{format}: {MyView, :app} Got: #{inspect(other)} """ end) put_private_formats(conn, private_key, kind, formats) end defp put_private_layout(conn, private_key, kind, no_format) do case no_format do false -> put_private_formats(conn, private_key, kind, %{_: false}) # TODO: Deprecate this branch on Phoenix v1.9 {mod, layout} when is_atom(mod) -> put_private_formats(conn, private_key, kind, %{_: {mod, layout}}) layout when is_binary(layout) or is_atom(layout) -> case Map.get(conn.private, private_key, %{_: false}) do %{_: {mod, _}} -> IO.warn(""" specifying put_layout(conn, template) or put_new_layout(conn, template) is deprecated, \ specify the layout with the format instead: put_layout(conn, html: #{inspect({mod, layout})}) """) put_private_formats(conn, private_key, kind, %{_: {mod, layout}}) %{_: false} -> raise "cannot use put_layout/2 or put_root_layout/2 with atom/binary when layout is false, use a tuple instead" %{} -> raise "you must pass the format when using put_layout/2 or put_root_layout/2 and a previous format was set, " <> "such as: put_layout(conn, html: #{inspect(layout)})" end end end @doc """ Stores the layout for rendering if one was not stored yet. See `put_layout/2` for more information. Raises `Plug.Conn.AlreadySentError` if `conn` is already sent. """ # TODO: Remove | layout from the spec once we deprecate put_new_layout on controllers @spec put_new_layout(Plug.Conn.t(), [{format :: atom, layout}] | layout) :: Plug.Conn.t() def put_new_layout(%Plug.Conn{state: state} = conn, layout) when (is_tuple(layout) and tuple_size(layout) == 2) or is_list(layout) or layout == false do unless state in @unsent do raise(AlreadySentError, """ the response was already sent. Status code: #{conn.status} Request path: #{conn.request_path} Method: #{conn.method} Layout: #{inspect(layout)} """) end put_private_layout(conn, :phoenix_layout, :new, layout) end @doc """ Stores the root layout for rendering. The layout must be given as keyword list where the key is the request format the layout will be applied to (such as `:html`) and the value is one of: * `{module, layout}` with the `module` the layout is defined and the name of the `layout` as an atom * `layout` when the name of the layout. This requires a layout for the given format in the shape of `{module, layout}` to be previously given * `false` which disables the layout ## Examples iex> root_layout(conn) false iex> conn = put_root_layout(conn, html: {AppView, :root}) iex> root_layout(conn) {AppView, :root} iex> conn = put_root_layout(conn, html: :bare) iex> root_layout(conn) {AppView, :bare} Raises `Plug.Conn.AlreadySentError` if `conn` is already sent. """ @spec put_root_layout(Plug.Conn.t(), [{format :: atom, layout}] | false) :: Plug.Conn.t() def put_root_layout(%Plug.Conn{state: state} = conn, layout) do if state in @unsent do put_private_layout(conn, :phoenix_root_layout, :replace, layout) else raise AlreadySentError, """ the response was already sent. Status code: #{conn.status} Request path: #{conn.request_path} Method: #{conn.method} Layout: #{inspect(layout)} """ end end @doc false @deprecated "put_layout_formats/2 is deprecated, pass a keyword list to put_layout/put_root_layout instead" @spec put_layout_formats(Plug.Conn.t(), [String.t()]) :: Plug.Conn.t() def put_layout_formats(%Plug.Conn{state: state} = conn, formats) when state in @unsent and is_list(formats) do put_private(conn, :phoenix_layout_formats, formats) end def put_layout_formats(%Plug.Conn{} = conn, _formats) do raise(AlreadySentError, """ the response was already sent. Status code: #{conn.status} Request path: #{conn.request_path} Method: #{conn.method} """) end @doc false @deprecated "layout_formats/1 is deprecated, pass a keyword list to put_layout/put_root_layout instead" @spec layout_formats(Plug.Conn.t()) :: [String.t()] def layout_formats(conn) do Map.get(conn.private, :phoenix_layout_formats, ~w(html)) end @doc """ Retrieves the current layout for the given format. If no format is given, takes the current one from the connection. """ @spec layout(Plug.Conn.t(), binary | nil) :: {atom, String.t() | atom} | false def layout(conn, format \\ nil) do get_private_layout(conn, :phoenix_layout, format) end @doc """ Retrieves the current root layout for the given format. If no format is given, takes the current one from the connection. """ @spec root_layout(Plug.Conn.t(), binary | nil) :: {atom, String.t() | atom} | false def root_layout(conn, format \\ nil) do get_private_layout(conn, :phoenix_root_layout, format) end defp get_private_layout(conn, priv_key, format) do format = format || get_safe_format(conn) # TODO: Remove _ handling once layouts(false) is set to remove all formats case conn.private[priv_key] do %{_: value} -> if format in [nil | layout_formats(conn)], do: value, else: false %{^format => value} -> value _ -> false end end @doc """ Render the given template or the default template specified by the current action with the given assigns. See `render/3` for more information. """ @spec render(Plug.Conn.t(), Keyword.t() | map | binary | atom) :: Plug.Conn.t() def render(conn, template_or_assigns \\ []) def render(conn, template) when is_binary(template) or is_atom(template) do render(conn, template, []) end def render(conn, assigns) do render(conn, action_name(conn), assigns) end @doc """ Renders the given `template` and `assigns` based on the `conn` information. Once the template is rendered, the template format is set as the response content type (for example, an HTML template will set "text/html" as response content type) and the data is sent to the client with default status of 200. ## Arguments * `conn` - the `Plug.Conn` struct * `template` - which may be an atom or a string. If an atom, like `:index`, it will render a template with the same format as the one returned by `get_format/1`. For example, for an HTML request, it will render the "index.html" template. If the template is a string, it must contain the extension too, like "index.json" * `assigns` - a dictionary with the assigns to be used in the view. Those assigns are merged and have higher precedence than the connection assigns (`conn.assigns`) ## Examples To render a template, you must configure your controller with the formats to render. You can do so on `use`, which will infer the modules based on the controller name: defmodule MyAppWeb.UserController do # Will use MyAppWeb.UserHTML and MyAppWeb.UserJSON use Phoenix.Controller, formats: [:html, :json] end With the formats set, you can render in two ways, either passing a string with the template name and explicit format: def show(conn, _params) do render(conn, "show.html", message: "Hello") end The example above renders a template "show.html" from the `MyAppWeb.UserHTML` and sets the response content type to "text/html". Or, if you want the template format to be set dynamically based on the request, you can pass an atom instead (without the extension): def show(conn, _params) do render(conn, :show, message: "Hello") end If the formats are not known at compile-time, you can call `put_view/2` at runtime: defmodule MyAppWeb.UserController do use Phoenix.Controller def show(conn, _params) do conn |> put_view(html: MyAppWeb.UserHTML) |> render("show.html", message: "Hello") end end """ @spec render(Plug.Conn.t(), binary | atom, Keyword.t() | map) :: Plug.Conn.t() def render(conn, template, assigns) when is_atom(template) and (is_map(assigns) or is_list(assigns)) do format = get_format(conn) || raise "cannot render template #{inspect(template)} because conn.params[\"_format\"] is not set. " <> "Please set `plug :accepts, ~w(html json ...)` in your pipeline." render_and_send(conn, format, Atom.to_string(template), assigns) end def render(conn, template, assigns) when is_binary(template) and (is_map(assigns) or is_list(assigns)) do {base, format} = split_template(template) conn |> put_format(format) |> render_and_send(format, base, assigns) end def render(conn, view, template) when is_atom(view) and (is_binary(template) or is_atom(template)) do IO.warn( "Phoenix.Controller.render/3 with a view is deprecated, see the documentation for render/3 for an alternative" ) render(conn, view, template, []) end @doc false @deprecated "render/4 is deprecated. Use put_view + render/3" def render(conn, view, template, assigns) when is_atom(view) and (is_binary(template) or is_atom(template)) do conn |> put_view(view) |> render(template, assigns) end defp render_and_send(conn, format, template, assigns) do view = view_module(conn, format) conn = prepare_assigns(conn, assigns, template, format) data = render_with_layouts(conn, view, template, format) conn |> ensure_resp_content_type(MIME.type(format)) |> send_resp(conn.status || 200, data) end defp render_with_layouts(conn, view, template, format) do render_assigns = Map.put(conn.assigns, :conn, conn) case root_layout(conn, format) do {layout_mod, layout_tpl} -> {layout_base, _} = split_template(layout_tpl) inner = template_render(view, template, format, render_assigns) root_assigns = render_assigns |> Map.put(:inner_content, inner) |> Map.delete(:layout) template_render_to_iodata(layout_mod, layout_base, format, root_assigns) false -> template_render_to_iodata(view, template, format, render_assigns) end end defp template_render(view, template, format, assigns) do metadata = %{view: view, template: template, format: format} :telemetry.span([:phoenix, :controller, :render], metadata, fn -> {Phoenix.Template.render(view, template, format, assigns), metadata} end) end defp template_render_to_iodata(view, template, format, assigns) do metadata = %{view: view, template: template, format: format} :telemetry.span([:phoenix, :controller, :render], metadata, fn -> {Phoenix.Template.render_to_iodata(view, template, format, assigns), metadata} end) end defp prepare_assigns(conn, assigns, template, format) do assigns = to_map(assigns) layout = case assigns_layout(conn, assigns, format) do {mod, layout} when is_binary(layout) -> {mod, Path.rootname(layout)} {mod, layout} when is_atom(layout) -> {mod, Atom.to_string(layout)} false -> false end conn |> put_private(:phoenix_template, template <> "." <> format) |> Map.update!(:assigns, fn prev -> prev |> Map.merge(assigns) |> Map.put(:layout, layout) end) end defp assigns_layout(_conn, %{layout: layout}, _format), do: layout defp assigns_layout(conn, _assigns, format) do # TODO: Remove _ handling once layouts(false) is set to remove all formats case conn.private[:phoenix_layout] do %{^format => bad_value, _: good_value} when good_value != false -> IO.warn(""" conflicting layouts found. A layout has been set with format, such as: put_layout(conn, #{format}: #{inspect(bad_value)}) But also without format: put_layout(conn, #{inspect(good_value)}) In this case, the layout without format will always win. Passing the layout without a format is currently soft-deprecated. If you use layouts with formats, make sure that they are used everywhere. Also remember to configure your controller to use layouts with formats: use Phoenix.Controller, layouts: [#{format}: #{inspect(bad_value)}] """) if format in layout_formats(conn), do: good_value, else: false %{_: value} -> if format in layout_formats(conn), do: value, else: false %{^format => value} -> value _ -> false end end defp to_map(assigns) when is_map(assigns), do: assigns defp to_map(assigns) when is_list(assigns), do: :maps.from_list(assigns) defp split_template(name) when is_atom(name), do: {Atom.to_string(name), nil} defp split_template(name) when is_binary(name) do case :binary.split(name, ".") do [base, format] -> {base, format} [^name] -> raise "cannot render template #{inspect(name)} without format. Use an atom if the " <> "template format is meant to be set dynamically based on the request format" [base | formats] -> {base, List.last(formats)} end end defp send_resp(conn, default_status, default_content_type, body) do conn |> ensure_resp_content_type(default_content_type) |> send_resp(conn.status || default_status, body) end defp ensure_resp_content_type(%Plug.Conn{resp_headers: resp_headers} = conn, content_type) do if List.keyfind(resp_headers, "content-type", 0) do conn else content_type = content_type <> "; charset=utf-8" %{conn | resp_headers: [{"content-type", content_type} | resp_headers]} end end @doc """ Puts the url string or `%URI{}` to be used for route generation. This function overrides the default URL generation pulled from the `%Plug.Conn{}`'s endpoint configuration. ## Examples Imagine your application is configured to run on "example.com" but after the user signs in, you want all links to use "some_user.example.com". You can do so by setting the proper router url configuration: def put_router_url_by_user(conn) do put_router_url(conn, get_user_from_conn(conn).account_name <> ".example.com") end Now when you call `Routes.some_route_url(conn, ...)`, it will use the router url set above. Keep in mind that, if you want to generate routes to the *current* domain, it is preferred to use `Routes.some_route_path` helpers, as those are always relative. """ def put_router_url(conn, %URI{} = uri) do put_private(conn, :phoenix_router_url, URI.to_string(uri)) end def put_router_url(conn, url) when is_binary(url) do put_private(conn, :phoenix_router_url, url) end @doc """ Puts the URL or `%URI{}` to be used for the static url generation. Using this function on a `%Plug.Conn{}` struct tells `static_url/2` to use the given information for URL generation instead of the `%Plug.Conn{}`'s endpoint configuration (much like `put_router_url/2` but for static URLs). """ def put_static_url(conn, %URI{} = uri) do put_private(conn, :phoenix_static_url, URI.to_string(uri)) end def put_static_url(conn, url) when is_binary(url) do put_private(conn, :phoenix_static_url, url) end @doc """ Puts the format in the connection. This format is used when rendering a template as an atom. For example, `render(conn, :foo)` will render `"foo.FORMAT"` where the format is the one set here. The default format is typically set from the negotiation done in `accepts/2`. See `get_format/1` for retrieval. """ def put_format(conn, format), do: put_private(conn, :phoenix_format, to_string(format)) @doc """ Returns the request format, such as "json", "html". This format is used when rendering a template as an atom. For example, `render(conn, :foo)` will render `"foo.FORMAT"` where the format is the one set here. The default format is typically set from the negotiation done in `accepts/2`. """ def get_format(conn) do conn.private[:phoenix_format] || conn.params["_format"] end defp get_safe_format(conn) do conn.private[:phoenix_format] || case conn.params do %{"_format" => format} -> format %{} -> nil end end @doc """ Sends the given file or binary as a download. The second argument must be `{:binary, contents}`, where `contents` will be sent as download, or`{:file, path}`, where `path` is the filesystem location of the file to be sent. Be careful to not interpolate the path from external parameters, as it could allow traversal of the filesystem. The download is achieved by setting "content-disposition" to attachment. The "content-type" will also be set based on the extension of the given filename but can be customized via the `:content_type` and `:charset` options. ## Options * `:filename` - the filename to be presented to the user as download * `:content_type` - the content type of the file or binary sent as download. It is automatically inferred from the filename extension * `:disposition` - specifies disposition type (`:attachment` or `:inline`). If `:attachment` was used, user will be prompted to save the file. If `:inline` was used, the browser will attempt to open the file. Defaults to `:attachment`. * `:charset` - the charset of the file, such as "utf-8". Defaults to none * `:offset` - the bytes to offset when reading. Defaults to `0` * `:length` - the total bytes to read. Defaults to `:all` * `:encode` - encodes the filename using `URI.encode/2`. Defaults to `true`. When `false`, disables encoding. If you disable encoding, you need to guarantee there are no special characters in the filename, such as quotes, newlines, etc. Otherwise you can expose your application to security attacks ## Examples To send a file that is stored inside your application priv directory: path = Application.app_dir(:my_app, "priv/prospectus.pdf") send_download(conn, {:file, path}) When using `{:file, path}`, the filename is inferred from the given path but may also be set explicitly. To allow the user to download contents that are in memory as a binary or string: send_download(conn, {:binary, "world"}, filename: "hello.txt") See `Plug.Conn.send_file/3` and `Plug.Conn.send_resp/3` if you would like to access the low-level functions used to send files and responses via Plug. """ def send_download(conn, kind, opts \\ []) def send_download(conn, {:file, path}, opts) do filename = opts[:filename] || Path.basename(path) offset = opts[:offset] || 0 length = opts[:length] || :all conn |> prepare_send_download(filename, opts) |> send_file(conn.status || 200, path, offset, length) end def send_download(conn, {:binary, contents}, opts) do filename = opts[:filename] || raise ":filename option is required when sending binary download" conn |> prepare_send_download(filename, opts) |> send_resp(conn.status || 200, contents) end defp prepare_send_download(conn, filename, opts) do content_type = opts[:content_type] || MIME.from_path(filename) encoded_filename = encode_filename(filename, Keyword.get(opts, :encode, true)) disposition_type = get_disposition_type(Keyword.get(opts, :disposition, :attachment)) warn_if_ajax(conn) disposition = ~s[#{disposition_type}; filename="#{encoded_filename}"] disposition = if encoded_filename != filename do disposition <> "; filename*=utf-8''#{encoded_filename}" else disposition end conn |> put_resp_content_type(content_type, opts[:charset]) |> put_resp_header("content-disposition", disposition) end defp encode_filename(filename, false), do: filename defp encode_filename(filename, true), do: URI.encode(filename, &URI.char_unreserved?/1) defp get_disposition_type(:attachment), do: "attachment" defp get_disposition_type(:inline), do: "inline" defp get_disposition_type(other), do: raise( ArgumentError, "expected :disposition to be :attachment or :inline, got: #{inspect(other)}" ) defp ajax?(conn) do case get_req_header(conn, "x-requested-with") do [value] -> value in ["XMLHttpRequest", "xmlhttprequest"] [] -> false end end defp warn_if_ajax(conn) do if ajax?(conn) do Logger.warning( "send_download/3 has been invoked during an AJAX request. " <> "The download may not work as expected under XMLHttpRequest" ) end end @doc """ Scrubs the parameters from the request. This process is two-fold: * Checks to see if the `required_key` is present * Changes empty parameters of `required_key` (recursively) to nils This function is useful for removing empty strings sent via HTML forms. If you are providing an API, there is likely no need to invoke `scrub_params/2`. If the `required_key` is not present, it will raise `Phoenix.MissingParamError`. ## Examples iex> scrub_params(conn, "user") """ @spec scrub_params(Plug.Conn.t(), String.t()) :: Plug.Conn.t() def scrub_params(%Plug.Conn{} = conn, required_key) when is_binary(required_key) do param = Map.get(conn.params, required_key) |> scrub_param() unless param do raise Phoenix.MissingParamError, key: required_key end params = Map.put(conn.params, required_key, param) %{conn | params: params} end defp scrub_param(%{__struct__: mod} = struct) when is_atom(mod) do struct end defp scrub_param(%{} = param) do Enum.reduce(param, %{}, fn {k, v}, acc -> Map.put(acc, k, scrub_param(v)) end) end defp scrub_param(param) when is_list(param) do Enum.map(param, &scrub_param/1) end defp scrub_param(param) do if scrub?(param), do: nil, else: param end defp scrub?(" " <> rest), do: scrub?(rest) defp scrub?(""), do: true defp scrub?(_), do: false @doc """ Enables CSRF protection. Currently used as a wrapper function for `Plug.CSRFProtection` and mainly serves as a function plug in `YourApp.Router`. Check `get_csrf_token/0` and `delete_csrf_token/0` for retrieving and deleting CSRF tokens. """ def protect_from_forgery(conn, opts \\ []) do Plug.CSRFProtection.call(conn, Plug.CSRFProtection.init(opts)) end @doc """ Put headers that improve browser security. It sets the following headers, if they are not already set: * `content-security-policy` - It sets `frame-ancestors` and `base-uri` to `self`, restricting embedding and the use of `` element to same origin respectively. It is equivalent to setting `"base-uri 'self'; frame-ancestors 'self';"` * `referrer-policy` - only send origin on cross origin requests * `x-content-type-options` - set to nosniff. This requires script and style tags to be sent with proper content type * `x-permitted-cross-domain-policies` - set to none to restrict Adobe Flash Player’s access to data A custom headers map may also be given to be merged with defaults. It is recommended for custom header keys to be in lowercase, to avoid sending duplicate keys or invalid responses. """ def put_secure_browser_headers(conn, headers \\ %{}) def put_secure_browser_headers(conn, []) do put_secure_defaults(conn) end def put_secure_browser_headers(conn, headers) when is_map(headers) do conn |> put_secure_defaults() |> merge_resp_headers(headers) end defp put_secure_defaults(%Plug.Conn{resp_headers: resp_headers} = conn) do headers = [ {"referrer-policy", "strict-origin-when-cross-origin"}, {"content-security-policy", "base-uri 'self'; frame-ancestors 'self';"}, {"x-content-type-options", "nosniff"}, {"x-permitted-cross-domain-policies", "none"} ] resp_headers = Enum.reduce(headers, resp_headers, fn {key, _} = pair, acc -> case :lists.keymember(key, 1, acc) do true -> acc false -> [pair | acc] end end) %{conn | resp_headers: resp_headers} end @doc """ Gets or generates a CSRF token. If a token exists, it is returned, otherwise it is generated and stored in the process dictionary. """ defdelegate get_csrf_token(), to: Plug.CSRFProtection @doc """ Deletes the CSRF token from the process dictionary. *Note*: The token is deleted only after a response has been sent. """ defdelegate delete_csrf_token(), to: Plug.CSRFProtection @doc """ Performs content negotiation based on the available formats. It receives a connection, a list of formats that the server is capable of rendering and then proceeds to perform content negotiation based on the request information. If the client accepts any of the given formats, the request proceeds. If the request contains a "_format" parameter, it is considered to be the format desired by the client. If no "_format" parameter is available, this function will parse the "accept" header and find a matching format accordingly. This function is useful when you may want to serve different content-types (such as JSON and HTML) from the same routes. However, if you always have distinct routes, you can also disable content negotiation and simply hardcode your format of choice in your route pipelines: plug :put_format, "html" It is important to notice that browsers have historically sent bad accept headers. For this reason, this function will default to "html" format whenever: * the accepted list of arguments contains the "html" format * the accept header specified more than one media type preceded or followed by the wildcard media type "`*/*`" This function raises `Phoenix.NotAcceptableError`, which is rendered with status 406, whenever the server cannot serve a response in any of the formats expected by the client. ## Examples `accepts/2` can be invoked as a function: iex> accepts(conn, ["html", "json"]) or used as a plug: plug :accepts, ["html", "json"] plug :accepts, ~w(html json) ## Custom media types It is possible to add custom media types to your Phoenix application. The first step is to teach Plug about those new media types in your `config/config.exs` file: config :mime, :types, %{ "application/vnd.api+json" => ["json-api"] } The key is the media type, the value is a list of formats the media type can be identified with. For example, by using "json-api", you will be able to use templates with extension "index.json-api" or to force a particular format in a given URL by sending "?_format=json-api". After this change, you must recompile plug: $ mix deps.clean mime --build $ mix deps.get And now you can use it in accepts too: plug :accepts, ["html", "json-api"] """ @spec accepts(Plug.Conn.t(), [binary]) :: Plug.Conn.t() def accepts(conn, [_ | _] = accepted) do case conn.params do %{"_format" => format} -> handle_params_accept(conn, format, accepted) %{} -> handle_header_accept(conn, get_req_header(conn, "accept"), accepted) end end defp handle_params_accept(conn, format, accepted) do if format in accepted do put_format(conn, format) else raise Phoenix.NotAcceptableError, message: "unknown format #{inspect(format)}, expected one of #{inspect(accepted)}", accepts: accepted end end # In case there is no accept header or the header is */* # we use the first format specified in the accepts list. defp handle_header_accept(conn, header, [first | _]) when header == [] or header == ["*/*"] do put_format(conn, first) end # In case there is a header, we need to parse it. # But before we check for */* because if one exists and we serve html, # we unfortunately need to assume it is a browser sending us a request. defp handle_header_accept(conn, [header | _], accepted) do if header =~ "*/*" and "html" in accepted do put_format(conn, "html") else parse_header_accept(conn, String.split(header, ","), [], accepted) end end defp parse_header_accept(conn, [h | t], acc, accepted) do case Plug.Conn.Utils.media_type(h) do {:ok, type, subtype, args} -> exts = parse_exts(type, subtype) q = parse_q(args) if format = q === 1.0 && find_format(exts, accepted) do put_format(conn, format) else parse_header_accept(conn, t, [{-q, h, exts} | acc], accepted) end :error -> parse_header_accept(conn, t, acc, accepted) end end defp parse_header_accept(conn, [], acc, accepted) do acc |> Enum.sort() |> Enum.find_value(&parse_header_accept(conn, &1, accepted)) |> Kernel.||(refuse(conn, acc, accepted)) end defp parse_header_accept(conn, {_, _, exts}, accepted) do if format = find_format(exts, accepted) do put_format(conn, format) end end defp parse_q(args) do case Map.fetch(args, "q") do {:ok, float} -> case Float.parse(float) do {float, _} -> float :error -> 1.0 end :error -> 1.0 end end defp parse_exts("*", "*"), do: "*/*" defp parse_exts(type, "*"), do: type defp parse_exts(type, subtype), do: MIME.extensions(type <> "/" <> subtype) defp find_format("*/*", accepted), do: Enum.fetch!(accepted, 0) defp find_format(exts, accepted) when is_list(exts), do: Enum.find(exts, &(&1 in accepted)) defp find_format(_type_range, []), do: nil defp find_format(type_range, [h | t]) do mime_type = MIME.type(h) case Plug.Conn.Utils.media_type(mime_type) do {:ok, accepted_type, _subtype, _args} when type_range === accepted_type -> h _ -> find_format(type_range, t) end end @spec refuse(term(), [tuple], [binary]) :: no_return() defp refuse(_conn, given, accepted) do raise Phoenix.NotAcceptableError, accepts: accepted, message: """ no supported media type in accept header. Expected one of #{inspect(accepted)} but got the following formats: * #{Enum.map_join(given, "\n ", fn {_, header, exts} -> inspect(header) <> " with extensions: " <> inspect(exts) end)} To accept custom formats, register them under the :mime library in your config/config.exs file: config :mime, :types, %{ "application/xml" => ["xml"] } And then run `mix deps.clean --build mime` to force it to be recompiled. """ end @doc """ Fetches the flash storage. """ def fetch_flash(conn, _opts \\ []) do if Map.get(conn.assigns, :flash) do conn else session_flash = get_session(conn, "phoenix_flash") conn = persist_flash(conn, session_flash || %{}) register_before_send(conn, fn conn -> flash = conn.assigns.flash flash_size = map_size(flash) cond do is_nil(session_flash) and flash_size == 0 -> conn flash_size > 0 and conn.status in 300..308 -> put_session(conn, "phoenix_flash", flash) true -> delete_session(conn, "phoenix_flash") end end) end end @doc """ Merges a map into the flash. Returns the updated connection. ## Examples iex> conn = merge_flash(conn, info: "Welcome Back!") iex> Phoenix.Flash.get(conn.assigns.flash, :info) "Welcome Back!" """ def merge_flash(conn, enumerable) do map = for {k, v} <- enumerable, into: %{}, do: {flash_key(k), v} persist_flash(conn, Map.merge(Map.get(conn.assigns, :flash, %{}), map)) end @doc """ Persists a value in flash. `key` can be any atom or binary value. Phoenix does not enforce which keys are stored in the flash, as long as the values are internally consistent. By default, the Phoenix generators use `:info` and `:error` keys. Returns the updated connection. ## Examples iex> conn = put_flash(conn, :info, "Welcome Back!") iex> Phoenix.Flash.get(conn.assigns.flash, :info) "Welcome Back!" """ def put_flash(conn, key, message) do flash = Map.get(conn.assigns, :flash) || raise ArgumentError, message: "flash not fetched, call fetch_flash/2" persist_flash(conn, Map.put(flash, flash_key(key), message)) end @doc """ Returns a map of previously set flash messages or an empty map. ## Examples iex> get_flash(conn) %{} iex> conn = put_flash(conn, :info, "Welcome Back!") iex> get_flash(conn) %{"info" => "Welcome Back!"} """ @deprecated "get_flash/1 is deprecated. Use the @flash assign provided by the :fetch_flash plug" def get_flash(conn) do Map.get(conn.assigns, :flash) || raise ArgumentError, message: "flash not fetched, call fetch_flash/2" end @doc """ Returns a message from flash by `key` (or `nil` if no message is available for `key`). ## Examples iex> conn = put_flash(conn, :info, "Welcome Back!") iex> get_flash(conn, :info) "Welcome Back!" """ @deprecated "get_flash/2 is deprecated. Use Phoenix.Flash.get(@flash, key) instead" def get_flash(conn, key) do get_flash(conn)[flash_key(key)] end @doc """ Generates a status message from the template name. ## Examples iex> status_message_from_template("404.html") "Not Found" iex> status_message_from_template("whatever.html") "Internal Server Error" """ def status_message_from_template(template) do template |> String.split(".") |> hd() |> String.to_integer() |> Plug.Conn.Status.reason_phrase() rescue _ -> "Internal Server Error" end @doc """ Clears all flash messages. """ def clear_flash(conn) do persist_flash(conn, %{}) end defp flash_key(binary) when is_binary(binary), do: binary defp flash_key(atom) when is_atom(atom), do: Atom.to_string(atom) defp persist_flash(conn, value) do assign(conn, :flash, value) end @doc """ Returns the current request path with its default query parameters: iex> current_path(conn) "/users/123?existing=param" See `current_path/2` to override the default parameters. The path is normalized based on the `conn.script_name` and `conn.path_info`. For example, "/foo//bar/" will become "/foo/bar". If you want the original path, use `conn.request_path` instead. """ def current_path(%Plug.Conn{query_string: ""} = conn) do normalized_request_path(conn) end def current_path(%Plug.Conn{query_string: query_string} = conn) do normalized_request_path(conn) <> "?" <> query_string end @doc """ Returns the current path with the given query parameters. You may also retrieve only the request path by passing an empty map of params. ## Examples iex> current_path(conn) "/users/123?existing=param" iex> current_path(conn, %{new: "param"}) "/users/123?new=param" iex> current_path(conn, %{filter: %{status: ["draft", "published"]}}) "/users/123?filter[status][]=draft&filter[status][]=published" iex> current_path(conn, %{}) "/users/123" The path is normalized based on the `conn.script_name` and `conn.path_info`. For example, "/foo//bar/" will become "/foo/bar". If you want the original path, use `conn.request_path` instead. """ def current_path(%Plug.Conn{} = conn, params) when params == %{} do normalized_request_path(conn) end def current_path(%Plug.Conn{} = conn, params) do normalized_request_path(conn) <> "?" <> Plug.Conn.Query.encode(params) end defp normalized_request_path(%{path_info: info, script_name: script}) do "/" <> Enum.join(script ++ info, "/") end @doc """ Returns the current request url with its default query parameters: iex> current_url(conn) "https://www.example.com/users/123?existing=param" See `current_url/2` to override the default parameters. """ def current_url(%Plug.Conn{} = conn) do Phoenix.VerifiedRoutes.unverified_url(conn, current_path(conn)) end @doc ~S""" Returns the current request URL with query params. The path will be retrieved from the currently requested path via `current_path/1`. The scheme, host and others will be received from the URL configuration in your Phoenix endpoint. The reason we don't use the host and scheme information in the request is because most applications are behind proxies and the host and scheme may not actually reflect the host and scheme accessed by the client. If you want to access the url precisely as requested by the client, see `Plug.Conn.request_url/1`. ## Examples iex> current_url(conn) "https://www.example.com/users/123?existing=param" iex> current_url(conn, %{new: "param"}) "https://www.example.com/users/123?new=param" iex> current_url(conn, %{}) "https://www.example.com/users/123" ## Custom URL Generation In some cases, you'll need to generate a request's URL, but using a different scheme, different host, etc. This can be accomplished in two ways. If you want to do so in a case-by-case basis, you can define a custom function that gets the endpoint URI configuration and changes it accordingly. For example, to get the current URL always in HTTPS format: def current_secure_url(conn, params \\ %{}) do current_uri = MyAppWeb.Endpoint.struct_url() current_path = Phoenix.Controller.current_path(conn, params) Phoenix.VerifiedRoutes.unverified_url(%URI{current_uri | scheme: "https"}, current_path) end However, if you want all generated URLs to always have a certain schema, host, etc, you may use `put_router_url/2`. """ def current_url(%Plug.Conn{} = conn, %{} = params) do Phoenix.VerifiedRoutes.unverified_url(conn, current_path(conn, params)) end @doc """ Assigns multiple key-value pairs to the connection. Accepts a keyword list, a map, or a single-argument function. This function accepts a map or keyword list of assigns and merges them into the connection's assigns. It is equivalent to calling `Plug.Conn.assign/3` multiple times. If a function is given, it takes the current assigns as an argument and its return value will be merged into the current assigns. ## Examples assign(conn, name: "Alice", role: :admin) assign(conn, %{name: "Alice", role: :admin}) assign(conn, fn %{name: name, logo: logo} -> %{title: Enum.join([name, logo], " | ")} end) """ def assign(conn, keyword_or_map_or_fun) def assign(conn, fun) when is_function(fun, 1) do assign(conn, fun.(conn.assigns)) end defdelegate assign(conn, assigns), to: Plug.Conn, as: :merge_assigns @doc false def __plugs__(controller_module, opts) do if Keyword.get(opts, :put_default_views, true) do base = Phoenix.Naming.unsuffix(controller_module, "Controller") view = case Keyword.fetch(opts, :formats) do {:ok, formats} when is_list(formats) -> Enum.map(formats, fn format when is_atom(format) -> {format, :"#{base}#{String.upcase(to_string(format))}"} {format, suffix} -> {format, :"#{base}#{suffix}"} end) :error -> IO.warn( """ use #{inspect(controller_module)} must receive the :formats option with \ the formats you intend to render. To keep compatibility within your app, \ you can list it as: formats: [html: "View", json: "View", ...] Listing all formats your application renders. """, [] ) :"#{base}View" end layouts = case Keyword.fetch(opts, :layouts) do {:ok, formats} when is_list(formats) -> # TODO: Deprecate passing :layouts altogether in Phoenix v1.9, # use Phoenix.Controller should only set views Enum.map(formats, fn {format, mod} when is_atom(mod) -> {format, {mod, :app}} {format, {mod, template}} when is_atom(mod) and is_atom(template) -> {format, {mod, template}} other -> raise ArgumentError, """ expected :layouts to be a list of format module pairs of the form: [html: DemoWeb.Layouts] or [html: {DemoWeb.Layouts, :app}] Got: #{inspect(other)} """ end) :error -> cond do namespace = Keyword.get(opts, :namespace) -> layout = Module.concat(namespace, "LayoutView") IO.warn( """ the :namespace option given to #{inspect(controller_module)} is deprecated. Set "plug :put_layout, html: #{inspect(layout)}" instead\ """, [] ) {layout, :app} Keyword.has_key?(opts, :formats) -> [] true -> layout = controller_module |> Atom.to_string() |> String.split(".") |> Enum.drop(-1) |> Enum.take(2) |> Kernel.++(["LayoutView"]) |> Module.concat() {layout, :app} end end {layouts, view} else IO.warn( """ the :put_default_views option given to #{inspect(controller_module)} is deprecated. Set formats: [] instead\ """, [] ) false end end end ================================================ FILE: lib/phoenix/debug.ex ================================================ defmodule Phoenix.Debug do @moduledoc """ Functions for runtime introspection and debugging of Phoenix applications. This module provides utilities for inspecting and debugging Phoenix applications. At the moment, it only includes functions related to `Phoenix.Socket` and `Phoenix.Channel` processes. It allows you to: * List all currently connected `Phoenix.Socket` transport processes. * List all channels for a given `Phoenix.Socket` process. * Get the socket of a channel process. * Check if a process is a `Phoenix.Socket` or `Phoenix.Channel`. """ @doc """ Returns a list of all currently connected `Phoenix.Socket` transport processes. Note that custom sockets implementing the `Phoenix.Socket.Transport` behaviour are not listed. Each process corresponds to one connection that can have multiple channels. For example, when using Phoenix LiveView, the browser establishes a socket connection when initially navigating to the page, and each live navigation retains the same socket connection. Nested LiveViews also share the same connection, each being a different channel. See `Phoenix.Debug.channels/1`. ## Examples iex> Phoenix.Debug.list_sockets() [%{pid: #PID<0.123.0>, module: Phoenix.LiveView.Socket, id: nil}] """ def list_sockets do for pid <- Process.list(), dict = socket_process_dict(pid), not is_nil(dict) do {Phoenix.Socket, mod, id} = keyfind(dict, :"$process_label") %{pid: pid, module: mod, id: id} end end defp keyfind(list, key) do case List.keyfind(list, key, 0) do {^key, value} -> value _ -> nil end end defp socket_process_dict(pid) do # Phoenix.Socket sets the "$process_label" to {Phoenix.Socket, handler_module, id} with info when is_list(info) <- Process.info(pid, [:dictionary]), dictionary when not is_nil(dictionary) <- keyfind(info, :dictionary), label when not is_nil(label) <- keyfind(dictionary, :"$process_label"), {Phoenix.Socket, mod, id} when is_atom(mod) and (is_binary(id) or is_nil(id)) <- label do dictionary else _ -> nil end end @doc """ Returns true if the given pid is a `Phoenix.Socket` transport process. It returns `false` for custom sockets implementing the `Phoenix.Socket.Transport` behaviour. ## Examples iex> Phoenix.Debug.list_sockets() |> Enum.at(0) |> Map.fetch!(:pid) |> socket_process?() true iex> socket_process?(pid(0,456,0)) false """ def socket_process?(pid) do not is_nil(socket_process_dict(pid)) end @doc """ Checks if the given pid is a `Phoenix.Channel` process. Note: this function returns false for [custom channels](https://hexdocs.pm/phoenix/Phoenix.Socket.html#module-custom-channels). """ def channel_process?(pid) do # Phoenix.Channel sets the "$process_label" to {Phoenix.Socket, handler_module, id} with info when is_list(info) <- Process.info(pid, [:dictionary]), dictionary when not is_nil(dictionary) <- keyfind(info, :dictionary), label when not is_nil(label) <- keyfind(dictionary, :"$process_label"), {Phoenix.Channel, mod, topic} when is_atom(mod) and is_binary(topic) <- label do true else _ -> false end end @doc """ Returns a list of all currently connected channels for the given `Phoenix.Socket` pid. Each channel is represented as a map with the following keys: - `:pid` - the pid of the channel process - `:status` - the status of the channel - `:topic` - the topic of the channel Note that this list also contains [custom channels](https://hexdocs.pm/phoenix/Phoenix.Socket.html#module-custom-channels) like LiveViews. You can check if a channel is a custom channel by using the `channel?/1` function, which returns `false` for custom channels. ## Examples iex> pid = Phoenix.Debug.list_sockets() |> Enum.at(0) |> Map.fetch!(:pid) iex> Phoenix.Debug.list_channels(pid) {:ok, [ %{pid: #PID<0.1702.0>, status: :joined, topic: "lv:phx-GDp9a9UZPiTxcgnE"}, %{pid: #PID<0.1727.0>, status: :joined, topic: "lv:sidebar"} ]} iex> Phoenix.Debug.list_channels(pid(0,456,0)) {:error, :not_alive} """ def list_channels(socket_pid) do ref = make_ref() if Process.alive?(socket_pid) and socket_process?(socket_pid) do send(socket_pid, {:debug_channels, ref, self()}) receive do {:debug_channels, ^ref, channels} -> {:ok, channels} after 5_000 -> {:error, :timeout} end else {:error, :not_alive} end end @doc """ Returns the socket of the channel process. Note: this only works for channels defined with `use Phoenix.Channel`. For LiveViews, use the functions defined in `Phoenix.LiveView.Debug` instead. ## Examples iex> pid = Phoenix.Debug.list_sockets() |> Enum.at(0) |> Map.fetch!(:pid) iex> {:ok, channels} = Phoenix.Debug.list_channels(pid) iex> channels |> Enum.at(0) |> Map.fetch!(:pid) |> socket() {:ok, %Phoenix.Socket{...}} iex> socket(pid(0,456,0)) {:error, :not_alive_or_not_a_channel} """ def socket(channel_pid) do if channel_process?(channel_pid) do {:ok, Phoenix.Channel.Server.socket(channel_pid)} else {:error, :not_alive_or_not_a_channel} end catch :exit, _ -> {:error, :not_alive_or_not_a_channel} end end ================================================ FILE: lib/phoenix/digester/compressor.ex ================================================ defmodule Phoenix.Digester.Compressor do @moduledoc ~S""" Defines the `Phoenix.Digester.Compressor` behaviour for implementing static file compressors. A custom compressor expects 2 functions to be implemented. By default, Phoenix uses only `Phoenix.Digester.Gzip` to compress static files, but additional compressors can be defined and added to the digest process. ## Example If you wanted to compress files using an external brotli compression library, you could define a new module implementing the behaviour and add the module to the list of configured Phoenix static compressors. defmodule MyApp.BrotliCompressor do @behaviour Phoenix.Digester.Compressor def compress_file(file_path, content) do valid_extension = Path.extname(file_path) in Application.fetch_env!(:phoenix, :gzippable_exts) {:ok, compressed_content} = :brotli.encode(content) if valid_extension && byte_size(compressed_content) < byte_size(content) do {:ok, compressed_content} else :error end end def file_extensions do [".br"] end end # config/config.exs config :phoenix, static_compressors: [Phoenix.Digester.Gzip, MyApp.BrotliCompressor], # ... """ @callback compress_file(Path.t(), binary()) :: {:ok, binary()} | :error @callback file_extensions() :: nonempty_list(String.t()) end ================================================ FILE: lib/phoenix/digester/gzip.ex ================================================ defmodule Phoenix.Digester.Gzip do @moduledoc ~S""" Gzip compressor for Phoenix.Digester """ @behaviour Phoenix.Digester.Compressor def compress_file(file_path, content) do if Path.extname(file_path) in Application.fetch_env!(:phoenix, :gzippable_exts) do {:ok, :zlib.gzip(content)} else :error end end def file_extensions do [".gz"] end end ================================================ FILE: lib/phoenix/digester.ex ================================================ defmodule Phoenix.Digester do @manifest_version 1 @empty_manifest %{ "version" => @manifest_version, "digests" => %{}, "latest" => %{} } defp now() do :calendar.datetime_to_gregorian_seconds(:calendar.universal_time()) end @moduledoc false @doc """ Digests and compresses the static files in the given `input_path` and saves them in the given `output_path`. """ @spec compile(String.t(), String.t(), boolean()) :: :ok | {:error, :invalid_path} def compile(input_path, output_path, with_vsn?) do if File.exists?(input_path) do File.mkdir_p!(output_path) files = filter_files(input_path) files = fixup_sourcemaps(files) latest = generate_latest(files) digests = load_compile_digests(output_path) digested_files = Enum.map(files, &digested_contents(&1, latest, with_vsn?)) save_manifest(digested_files, latest, digests, output_path) digested_files |> Task.async_stream(&write_to_disk(&1, output_path), ordered: false, timeout: :infinity) |> Stream.run() else {:error, :invalid_path} end end defp filter_files(input_path) do input_path |> Path.join("**") |> Path.wildcard() |> Enum.filter(&(not (File.dir?(&1) or compiled_file?(&1)))) |> Enum.map(&map_file(&1, input_path)) end defp fixup_sourcemaps(files) when is_list(files) do Enum.map(files, &maybe_fixup_sourcemap(&1, files)) end defp maybe_fixup_sourcemap(sourcemap, files) do if Path.extname(sourcemap.filename) == ".map" do fixup_sourcemap(sourcemap, files) else sourcemap end end defp fixup_sourcemap(%{} = sourcemap, files) do asset_path = Path.rootname(sourcemap.absolute_path, ".map") asset = Enum.find(files, fn file -> file.absolute_path == asset_path end) if asset do new_digested_filename = asset.digested_filename <> ".map" %{sourcemap | digest: asset.digest, digested_filename: new_digested_filename} else sourcemap end end defp generate_latest(files) do Map.new( files, &{ manifest_join(&1.relative_path, &1.filename), manifest_join(&1.relative_path, &1.digested_filename) } ) end defp load_compile_digests(output_path) do manifest = load_manifest(output_path) manifest["digests"] end defp load_manifest(output_path) do manifest_path = Path.join(output_path, "cache_manifest.json") if File.exists?(manifest_path) do manifest_path |> File.read!() |> Phoenix.json_library().decode!() |> migrate_manifest(output_path) else @empty_manifest end end defp migrate_manifest(%{"version" => @manifest_version} = manifest, _output_path), do: manifest defp migrate_manifest(_latest, _output_path), do: @empty_manifest defp save_manifest(files, latest, old_digests, output_path) do old_digests_that_still_exist = old_digests |> Enum.filter(fn {file, _} -> File.exists?(Path.join(output_path, file)) end) |> Map.new() digests = Map.merge(old_digests_that_still_exist, generate_digests(files)) write_manifest(latest, digests, output_path) end @comment "This file was auto-generated by `mix phx.digest`. Remove it and all generated artefacts with `mix phx.digest.clean --all`" defp write_manifest(latest, digests, output_path) do encoder = Phoenix.json_library() json = """ { "!comment!":#{encoder.encode!(@comment)}, "version":#{encoder.encode!(@manifest_version)}, "latest":#{encoder.encode!(latest)}, "digests":#{encoder.encode!(digests)} } """ File.write!(Path.join(output_path, "cache_manifest.json"), json) end defp remove_manifest(output_path) do File.rm(Path.join(output_path, "cache_manifest.json")) end defp generate_digests(files) do Map.new( files, &{ manifest_join(&1.relative_path, &1.digested_filename), build_digest(&1) } ) end defp build_digest(file) do %{ logical_path: manifest_join(file.relative_path, file.filename), mtime: now(), size: file.size, digest: file.digest, sha512: Base.encode64(:crypto.hash(:sha512, file.digested_content)) } end defp manifest_join(".", filename), do: filename defp manifest_join(path, filename), do: Path.join(path, filename) defp compiled_file?(file_path) do digested_file_regex = ~r/(-[a-fA-F\d]{32})/ Regex.match?(digested_file_regex, Path.basename(file_path)) || Path.extname(file_path) in compressed_extensions() || Path.basename(file_path) == "cache_manifest.json" end defp compressed_extensions do compressors = Application.fetch_env!(:phoenix, :static_compressors) Enum.flat_map(compressors, & &1.file_extensions()) end defp map_file(file_path, input_path) do stats = File.stat!(file_path) content = File.read!(file_path) basename = Path.basename(file_path) rootname = Path.rootname(basename) extension = Path.extname(basename) digest = Base.encode16(:erlang.md5(content), case: :lower) %{ absolute_path: file_path, relative_path: file_path |> Path.relative_to(input_path) |> Path.dirname(), filename: basename, size: stats.size, content: content, digest: digest, digested_content: nil, digested_filename: "#{rootname}-#{digest}#{extension}" } end defp write_to_disk(file, output_path) do path = Path.join(output_path, file.relative_path) File.mkdir_p!(path) compressors = Application.fetch_env!(:phoenix, :static_compressors) Enum.each(compressors, fn compressor -> [file_extension | _] = compressor.file_extensions() compressed_digested_result = compressor.compress_file(file.digested_filename, file.digested_content) with {:ok, compressed_digested} <- compressed_digested_result do File.write!( Path.join(path, file.digested_filename <> file_extension), compressed_digested ) end compress_result = if file.digested_content == file.content, do: compressed_digested_result, else: compressor.compress_file(file.filename, file.content) with {:ok, compressed} <- compress_result do File.write!( Path.join(path, file.filename <> file_extension), compressed ) end end) # uncompressed files File.write!(Path.join(path, file.digested_filename), file.digested_content) File.write!(Path.join(path, file.filename), file.content) file end defp digested_contents(file, latest, with_vsn?) do ext = Path.extname(file.filename) digested_content = case ext do ".css" -> digest_stylesheet_asset_references(file, latest, with_vsn?) ".js" -> digest_javascript_asset_references(file, latest) ".map" -> digest_javascript_map_asset_references(file, latest) _ -> file.content end %{file | digested_content: digested_content} end defp digest_stylesheet_asset_references(file, latest, with_vsn?) do stylesheet_url_regex = ~r{(url\(\s*)(\S+?)(\s*\))} quoted_text_regex = ~r{\A(['"])(.+)\1\z} Regex.replace(stylesheet_url_regex, file.content, fn _, open, url, close -> case Regex.run(quoted_text_regex, url) do [_, quote_symbol, url] -> open <> quote_symbol <> digested_url(url, file, latest, with_vsn?) <> quote_symbol <> close nil -> open <> digested_url(url, file, latest, with_vsn?) <> close end end) end defp digest_javascript_asset_references(file, latest) do javascript_source_map_regex = ~r{(//#\s*sourceMappingURL=\s*)(\S+)} Regex.replace(javascript_source_map_regex, file.content, fn _, source_map_text, url -> source_map_text <> digested_url(url, file, latest, false) end) end defp digest_javascript_map_asset_references(file, latest) do javascript_map_file_regex = ~r{(['"]file['"]:['"])([^,"']+)(['"])} Regex.replace(javascript_map_file_regex, file.content, fn _, open_text, url, close_text -> open_text <> digested_url(url, file, latest, false) <> close_text end) end defp digested_url("/" <> relative_path, _file, latest, with_vsn?) do case Map.fetch(latest, relative_path) do {:ok, digested_path} -> relative_digested_path(digested_path, with_vsn?) :error -> "/" <> relative_path end end defp digested_url(url, file, latest, with_vsn?) do case URI.parse(url) do %URI{scheme: nil, host: nil} -> manifest_path = file.relative_path |> Path.join(url) |> Path.expand() |> Path.relative_to_cwd() case Map.fetch(latest, manifest_path) do {:ok, digested_path} -> absolute_digested_url(url, digested_path, with_vsn?) :error -> url end _ -> url end end defp relative_digested_path(digested_path, true), do: relative_digested_path(digested_path) <> "?vsn=d" defp relative_digested_path(digested_path, false), do: relative_digested_path(digested_path) defp relative_digested_path(digested_path), do: "/" <> digested_path defp absolute_digested_url(url, digested_path, true), do: absolute_digested_url(url, digested_path) <> "?vsn=d" defp absolute_digested_url(url, digested_path, false), do: absolute_digested_url(url, digested_path) defp absolute_digested_url(url, digested_path), do: url |> Path.dirname() |> Path.join(Path.basename(digested_path)) @doc """ Deletes compiled/compressed asset files that are no longer in use based on the specified criteria. ## Arguments * `path` - The path where the compiled/compressed files are saved * `age` - The max age of assets to keep in seconds * `keep` - The number of old versions to keep """ @spec clean(String.t(), integer, integer, integer) :: :ok | {:error, :invalid_path} def clean(path, age, keep, now \\ now()) do if File.exists?(path) do %{"latest" => latest, "digests" => digests} = load_manifest(path) files = files_to_clean(latest, digests, now - age, keep) remove_files(files, path) write_manifest(latest, Map.drop(digests, files), path) :ok else {:error, :invalid_path} end end @doc """ Deletes compiled/compressed asset files, including the cache manifest. ## Arguments * `path` - The path where the compiled/compressed files are saved """ @spec clean_all(String.t()) :: :ok | {:error, :invalid_path} def clean_all(path) do if File.exists?(path) do %{"digests" => digests} = load_manifest(path) grouped_digests = group_by_logical_path(digests) logical_paths = Map.keys(grouped_digests) files = for {_, versions} <- grouped_digests, file <- Enum.map(versions, fn {path, _attrs} -> path end), do: file remove_files(files, path) remove_compressed_files(logical_paths, path) remove_manifest(path) :ok else {:error, :invalid_path} end end defp files_to_clean(latest, digests, max_age, keep) do digests = Map.drop(digests, Map.values(latest)) for {_, versions} <- group_by_logical_path(digests), file <- versions_to_clean(versions, max_age, keep), do: file end defp versions_to_clean(versions, max_age, keep) do versions |> Enum.map(fn {path, attrs} -> Map.put(attrs, "path", path) end) |> Enum.sort_by(& &1["mtime"], &>/2) |> Enum.with_index(1) |> Enum.filter(fn {version, index} -> max_age > version["mtime"] || index > keep end) |> Enum.map(fn {version, _index} -> version["path"] end) end defp group_by_logical_path(digests) do Enum.group_by(digests, fn {_, attrs} -> attrs["logical_path"] end) end defp remove_files(files, output_path) do for file <- files do output_path |> Path.join(file) |> File.rm() remove_compressed_file(file, output_path) end end defp remove_compressed_files(files, output_path) do for file <- files, do: remove_compressed_file(file, output_path) end defp remove_compressed_file(file, output_path) do compressed_extensions() |> Enum.map(fn extension -> Path.join(output_path, file <> extension) end) |> Enum.each(&File.rm/1) end end ================================================ FILE: lib/phoenix/endpoint/cowboy2_adapter.ex ================================================ defmodule Phoenix.Endpoint.Cowboy2Adapter do @moduledoc """ The Cowboy2 adapter for Phoenix. ## Endpoint configuration This adapter uses the following endpoint configuration: * `:http` - the configuration for the HTTP server. It accepts all options as defined by [`Plug.Cowboy`](https://hexdocs.pm/plug_cowboy/). Defaults to `false` * `:https` - the configuration for the HTTPS server. It accepts all options as defined by [`Plug.Cowboy`](https://hexdocs.pm/plug_cowboy/). Defaults to `false` * `:drainer` - a drainer process that triggers when your application is shutting down to wait for any on-going request to finish. It accepts all options as defined by [`Plug.Cowboy.Drainer`](https://hexdocs.pm/plug_cowboy/Plug.Cowboy.Drainer.html). Defaults to `[]`, which will start a drainer process for each configured endpoint, but can be disabled by setting it to `false`. ## Custom dispatch options You can provide custom dispatch options in order to use Phoenix's builtin Cowboy server with custom handlers. For example, to handle raw WebSockets [as shown in Cowboy's docs](https://github.com/ninenines/cowboy/tree/master/examples)). The options are passed to both `:http` and `:https` keys in the endpoint configuration. However, once you pass your custom dispatch options, you will need to manually wire the Phoenix endpoint by adding the following rule: {:_, Plug.Cowboy.Handler, {MyAppWeb.Endpoint, []}} For example: config :myapp, MyAppWeb.Endpoint, http: [dispatch: [ {:_, [ {"/foo", MyAppWeb.CustomHandler, []}, {:_, Plug.Cowboy.Handler, {MyAppWeb.Endpoint, []}} ]}]] It is also important to specify your handlers first, otherwise Phoenix will intercept the requests before they get to your handler. """ require Logger @doc false def child_specs(endpoint, config) do otp_app = Keyword.fetch!(config, :otp_app) refs_and_specs = for {scheme, port} <- [http: 4000, https: 4040], opts = config[scheme] do port = :proplists.get_value(:port, opts, port) unless port do Logger.error(":port for #{scheme} config is nil, cannot start server") raise "aborting due to nil port" end # Ranch options are read from the top, so we keep the user opts first. opts = :proplists.delete(:port, opts) ++ [port: port_to_integer(port), otp_app: otp_app] child_spec(scheme, endpoint, opts, config[:code_reloader]) end {refs, child_specs} = Enum.unzip(refs_and_specs) if drainer = refs != [] && Keyword.get(config, :drainer, []) do child_specs ++ [{Plug.Cowboy.Drainer, Keyword.put_new(drainer, :refs, refs)}] else child_specs end end defp child_spec(scheme, endpoint, config, code_reloader?) do if scheme == :https do Application.ensure_all_started(:ssl) end ref = make_ref(endpoint, scheme) plug = if code_reloader? do {Phoenix.Endpoint.SyncCodeReloadPlug, {endpoint, []}} else {endpoint, []} end spec = Plug.Cowboy.child_spec(ref: ref, scheme: scheme, plug: plug, options: config) spec = update_in(spec.start, &{__MODULE__, :start_link, [scheme, endpoint, &1]}) {ref, spec} end @doc false def start_link(scheme, endpoint, {m, f, [ref | _] = a}) do # ref is used by Ranch to identify its listeners, defaulting # to plug.HTTP and plug.HTTPS and overridable by users. case apply(m, f, a) do {:ok, pid} -> Logger.info(info(scheme, endpoint, ref)) {:ok, pid} {:error, {:shutdown, {_, _, {:listen_error, _, :eaddrinuse}}}} = error -> Logger.error([info(scheme, endpoint, ref), " failed, port already in use"]) error {:error, {:shutdown, {_, _, {{_, {:error, :eaddrinuse}}, _}}}} = error -> Logger.error([info(scheme, endpoint, ref), " failed, port already in use"]) error {:error, _} = error -> error end end defp info(scheme, endpoint, ref) do server = "cowboy #{Application.spec(:cowboy)[:vsn]}" "Running #{inspect(endpoint)} with #{server} at #{bound_address(scheme, ref)}" end defp bound_address(scheme, ref) do case :ranch.get_addr(ref) do {:local, unix_path} -> "#{unix_path} (#{scheme}+unix)" {addr, port} -> "#{:inet.ntoa(addr)}:#{port} (#{scheme})" end rescue _ -> scheme end # TODO: Remove this once {:system, env_var} deprecation is removed defp port_to_integer({:system, env_var}), do: port_to_integer(System.get_env(env_var)) defp port_to_integer(port) when is_binary(port), do: String.to_integer(port) defp port_to_integer(port) when is_integer(port), do: port def server_info(endpoint, scheme) do address = endpoint |> make_ref(scheme) |> :ranch.get_addr() {:ok, address} rescue e -> {:error, Exception.message(e)} end defp make_ref(endpoint, scheme) do Module.concat(endpoint, scheme |> Atom.to_string() |> String.upcase()) end end ================================================ FILE: lib/phoenix/endpoint/render_errors.ex ================================================ defmodule Phoenix.Endpoint.RenderErrors do # This module is used to catch failures and render them using a view. # # This module is automatically used in `Phoenix.Endpoint` where it # overrides `call/2` to provide rendering. Once the error is # rendered, the error is reraised unless it is a NoRouteError. # # ## Options # # * `:formats` - the format to use when none is available from the request # * `:log` - the `t:Logger.level/0` or `false` to disable logging rendered errors # @moduledoc false import Plug.Conn require Logger alias Phoenix.Router.NoRouteError alias Phoenix.Controller @already_sent {:plug_conn, :sent} @doc false defmacro __using__(opts) do quote do @before_compile Phoenix.Endpoint.RenderErrors @phoenix_render_errors unquote(opts) end end @doc false defmacro __before_compile__(_) do quote location: :keep do defoverridable call: 2 def call(conn, opts) do try do super(conn, opts) rescue e in Plug.Conn.WrapperError -> %{conn: conn, kind: kind, reason: reason, stack: stack} = e unquote(__MODULE__).__catch__(conn, kind, reason, stack, @phoenix_render_errors) catch kind, reason -> stack = __STACKTRACE__ unquote(__MODULE__).__catch__(conn, kind, reason, stack, @phoenix_render_errors) end end end end @doc false def __catch__(%Plug.Conn{} = conn, kind, reason, stack, opts) do conn = receive do @already_sent -> send(self(), @already_sent) %{conn | state: :sent} after 0 -> instrument_render_and_send(conn, kind, reason, stack, opts) end maybe_raise(kind, reason, stack) conn end defp instrument_render_and_send(conn, kind, reason, stack, opts) do level = Keyword.get(opts, :log, :debug) status = status(kind, reason) conn = error_conn(conn, kind, reason) start = System.monotonic_time() metadata = %{ conn: conn, status: status, kind: kind, reason: reason, stacktrace: stack, log: level } try do render(conn, status, kind, reason, stack, opts) after duration = System.monotonic_time() - start :telemetry.execute([:phoenix, :error_rendered], %{duration: duration}, metadata) end end defp error_conn(_conn, :error, %NoRouteError{conn: conn}), do: conn defp error_conn(conn, _kind, _reason), do: conn defp maybe_raise(:error, %NoRouteError{}, _stack), do: :ok defp maybe_raise(kind, reason, stack), do: :erlang.raise(kind, reason, stack) ## Rendering @doc false def __debugger_banner__(_conn, _status, _kind, %NoRouteError{router: router}, _stack) do """

Available routes

#{Phoenix.Router.ConsoleFormatter.format(router)}
""" end def __debugger_banner__(_conn, _status, _kind, _reason, _stack), do: nil defp render(conn, status, kind, reason, stack, opts) do conn = conn |> maybe_fetch_query_params() |> fetch_view_format(opts) |> Plug.Conn.put_status(status) |> Controller.put_root_layout(opts[:root_layout] || false) |> Controller.put_layout(opts[:layout] || false) format = Controller.get_format(conn) reason = Exception.normalize(kind, reason, stack) template = "#{conn.status}.#{format}" assigns = %{kind: kind, reason: reason, stack: stack, status: conn.status, __changed__: nil} Controller.render(conn, template, assigns) end defp maybe_fetch_query_params(%Plug.Conn{} = conn) do fetch_query_params(conn) rescue Plug.Conn.InvalidQueryError -> case conn.params do %Plug.Conn.Unfetched{} -> %{conn | query_params: %{}, params: %{}} params -> %{conn | query_params: %{}, params: params} end end defp fetch_view_format(conn, opts) do # We ignore params["_format"] although we respect any already stored. view = opts[:view] formats = opts[:formats] accepts = opts[:accepts] cond do formats -> put_formats(conn, Enum.map(formats, fn {k, v} -> {Atom.to_string(k), v} end)) view && accepts -> put_formats(conn, Enum.map(accepts, &{&1, view})) true -> raise ArgumentError, "expected :render_errors to have :formats or :view/:accepts, but got: #{inspect(opts)}" end end defp put_formats(conn, formats) do [{fallback_format, fallback_view} | _] = formats try do conn = case conn.private do %{phoenix_format: format} when is_binary(format) -> conn _ -> Controller.accepts(conn, Enum.map(formats, &elem(&1, 0))) end format = Phoenix.Controller.get_format(conn) case List.keyfind(formats, format, 0) do {_, view} -> Controller.put_view(conn, view) nil -> conn |> Controller.put_format(fallback_format) |> Controller.put_view(fallback_view) end rescue e in Phoenix.NotAcceptableError -> Logger.debug( "Could not render errors due to #{Exception.message(e)}. " <> "Errors will be rendered using the first accepted format #{inspect(fallback_format)} as fallback. " <> "Please customize the :formats option under the :render_errors configuration " <> "in your endpoint if you want to support other formats or choose another fallback" ) conn |> Controller.put_format(fallback_format) |> Controller.put_view(fallback_view) end end defp status(:error, error), do: Plug.Exception.status(error) defp status(:throw, _throw), do: 500 defp status(:exit, _exit), do: 500 end ================================================ FILE: lib/phoenix/endpoint/supervisor.ex ================================================ defmodule Phoenix.Endpoint.Supervisor do # This module contains the logic used by most functions in Phoenix.Endpoint # as well the supervisor for sockets, adapters, watchers, etc. @moduledoc false require Logger use Supervisor @doc """ Starts the endpoint supervision tree. """ def start_link(otp_app, mod, opts \\ []) do with {:ok, pid} = ok <- Supervisor.start_link(__MODULE__, {otp_app, mod, opts}, name: mod) do # We don't use the defaults in the checks below conf = Keyword.merge(Application.get_env(otp_app, mod, []), opts) log_access_url(mod, conf) browser_open(mod, conf) measurements = %{system_time: System.system_time()} metadata = %{pid: pid, config: conf, module: mod, otp_app: otp_app} :telemetry.execute([:phoenix, :endpoint, :init], measurements, metadata) ok end end @doc false def init({otp_app, mod, opts}) do default_conf = Phoenix.Config.merge(defaults(otp_app, mod), opts) env_conf = Phoenix.Config.from_env(otp_app, mod, default_conf) secret_conf = cond do Code.ensure_loaded?(mod) and function_exported?(mod, :init, 2) -> IO.warn( """ your #{inspect(mod)} defines a init/2 callback, which is now deprecated. \ This callback is invoked when your endpoint is initialized as part of your supervision tree. \ Instead, you should either: 1. Move all dynamic configuration to config/runtime.exs (preferred). For example: # config/runtime.exs import Config if config_env() == :prod do config #{inspect(otp_app)}, #{inspect(mod)}, http: [:inet6, port: System.fetch_env!("PORT")] end 2. Pass the configuration you returned from the `init/2` callback \ as additional options when starting the endpoint in your supervision tree. \ For example: {#{inspect(mod)}, some_extra_options: true} """, [] ) {:ok, init_conf} = mod.init(:supervisor, env_conf) init_conf is_nil(Application.get_env(otp_app, mod)) -> Logger.warning( "no configuration found for otp_app #{inspect(otp_app)} and module #{inspect(mod)}" ) env_conf true -> env_conf end extra_conf = [ endpoint_id: :crypto.strong_rand_bytes(16) |> Base.encode64(padding: false), # TODO: Remove this once :pubsub is removed pubsub_server: secret_conf[:pubsub_server] || secret_conf[:pubsub][:name] ] secret_conf = extra_conf ++ secret_conf default_conf = extra_conf ++ default_conf # Drop all secrets from secret_conf before passing it around conf = Keyword.drop(secret_conf, [:secret_key_base]) server? = server?(conf) if conf[:instrumenters] do Logger.warning( ":instrumenters configuration for #{inspect(mod)} is deprecated and has no effect" ) end if server? and conf[:code_reloader] do Phoenix.CodeReloader.Server.check_symlinks() end # TODO: Remove this once {:system, env_var} tuples are removed warn_on_deprecated_system_env_tuples(otp_app, mod, conf, :http) warn_on_deprecated_system_env_tuples(otp_app, mod, conf, :https) warn_on_deprecated_system_env_tuples(otp_app, mod, conf, :url) warn_on_deprecated_system_env_tuples(otp_app, mod, conf, :static_url) children = config_children(mod, secret_conf, default_conf) ++ warmup_children(mod) ++ pubsub_children(mod, conf) ++ socket_children(mod, conf, :child_spec) ++ server_children(mod, conf, server?) ++ socket_children(mod, conf, :drainer_spec) ++ watcher_children(mod, conf, server?) Supervisor.init(children, strategy: :one_for_one) end defp pubsub_children(mod, conf) do pub_conf = conf[:pubsub] if pub_conf do Logger.warning(""" The :pubsub key in your #{inspect(mod)} is deprecated. You must now start the pubsub in your application supervision tree. Go to lib/my_app/application.ex and add the following: {Phoenix.PubSub, #{inspect(pub_conf)}} Now, back in your config files in config/*, you can remove the :pubsub key and add the :pubsub_server key, with the PubSub name: pubsub_server: #{inspect(pub_conf[:name])} """) end if pub_conf[:adapter] do [{Phoenix.PubSub, pub_conf}] else [] end end defp socket_children(endpoint, conf, fun) do for {_, socket, opts} <- Enum.uniq_by(endpoint.__sockets__(), &elem(&1, 1)), _ = check_origin_or_csrf_checked!(conf, opts), spec = apply_or_ignore(socket, fun, [[endpoint: endpoint] ++ opts]), spec != :ignore do spec end end defp apply_or_ignore(socket, fun, args) do # If the module is not loaded, we want to invoke and crash if not Code.ensure_loaded?(socket) or function_exported?(socket, fun, length(args)) do apply(socket, fun, args) else :ignore end end defp check_origin_or_csrf_checked!(endpoint_conf, socket_opts) do check_origin = endpoint_conf[:check_origin] for {transport, transport_opts} <- socket_opts, is_list(transport_opts) do check_origin = Keyword.get(transport_opts, :check_origin, check_origin) check_csrf = transport_opts[:check_csrf] if check_origin == false and check_csrf == false do raise ArgumentError, "one of :check_origin and :check_csrf must be set to non-false value for " <> "transport #{inspect(transport)}" end end end defp config_children(mod, conf, default_conf) do args = {mod, conf, default_conf, name: Module.concat(mod, "Config")} [{Phoenix.Config, args}] end defp warmup_children(mod) do [%{id: :warmup, start: {__MODULE__, :warmup, [mod]}}] end defp server_children(mod, config, server?) do cond do server? -> adapter = config[:adapter] adapter.child_specs(mod, config) config[:http] || config[:https] -> if System.get_env("RELEASE_NAME") do Logger.info( "Configuration :server was not enabled for #{inspect(mod)}, http/https services won't start" ) end [] true -> [] end end defp watcher_children(_mod, conf, server?) do watchers = conf[:watchers] || [] if server? || conf[:force_watchers] do Enum.map(watchers, &{Phoenix.Endpoint.Watcher, &1}) else [] end end @doc """ Checks if Endpoint's web server has been configured to start. """ def server?(otp_app, endpoint) when is_atom(otp_app) and is_atom(endpoint) do server?(Application.get_env(otp_app, endpoint, [])) end defp server?(conf) when is_list(conf) do Keyword.get_lazy(conf, :server, fn -> Application.get_env(:phoenix, :serve_endpoints, false) end) end defp defaults(otp_app, module) do [ otp_app: otp_app, # Compile-time config code_reloader: false, debug_errors: false, render_errors: [view: render_errors(module), accepts: ~w(html), layout: false], # Runtime config # Even though Bandit is the default in apps generated via the installer, # we continue to use Cowboy as the default if not explicitly specified for # backwards compatibility. TODO: Change this to default to Bandit in 2.0 adapter: Phoenix.Endpoint.Cowboy2Adapter, cache_static_manifest: nil, check_origin: true, http: false, https: false, reloadable_apps: nil, # TODO: Gettext had a compiler in earlier versions, # but not since v0.20, so we can remove it here eventually. reloadable_compilers: [:phoenix_live_view, :gettext, :elixir, :app], secret_key_base: nil, static_url: nil, url: [host: "localhost", path: "/"], cache_manifest_skip_vsn: false, # Supervisor config watchers: [], force_watchers: false ] end defp render_errors(module) do module |> Module.split() |> Enum.at(0) |> Module.concat("ErrorView") end @doc """ Callback that changes the configuration from the app callback. """ def config_change(endpoint, changed, removed) do res = Phoenix.Config.config_change(endpoint, changed, removed) warmup(endpoint) res end @doc """ Returns a two item tuple with the first element containing the static path of a file in the static root directory and the second element containing the sha512 of that file (for SRI). When the file exists, it includes a timestamp. When it doesn't exist, just the static path is returned. The result is wrapped in a `{:cache | :nocache, value}` tuple so the `Phoenix.Config` layer knows how to cache it. """ @invalid_local_url_chars ["\\"] def static_lookup(_endpoint, "//" <> _ = path) do raise_invalid_path(path) end def static_lookup(_endpoint, "/" <> _ = path) do if String.contains?(path, @invalid_local_url_chars) do raise ArgumentError, "unsafe characters detected for path #{inspect(path)}" else {:nocache, {path, nil}} end end def static_lookup(_endpoint, path) when is_binary(path) do raise_invalid_path(path) end defp raise_invalid_path(path) do raise ArgumentError, "expected a path starting with a single / but got #{inspect(path)}" end # TODO: Remove the first function clause once {:system, env_var} tuples are removed defp host_to_binary({:system, env_var}), do: host_to_binary(System.get_env(env_var)) defp host_to_binary(host), do: host # TODO: Remove the first function clause once {:system, env_var} tuples are removed defp port_to_integer({:system, env_var}), do: port_to_integer(System.get_env(env_var)) defp port_to_integer(port) when is_binary(port), do: String.to_integer(port) defp port_to_integer(port) when is_integer(port), do: port defp warn_on_deprecated_system_env_tuples(otp_app, mod, conf, key) do deprecated_configs = Enum.filter(conf[key] || [], &match?({_, {:system, _}}, &1)) if Enum.any?(deprecated_configs) do deprecated_config_lines = for {k, v} <- deprecated_configs, do: "#{k}: #{inspect(v)}" runtime_exs_config_lines = for {key, {:system, env_var}} <- deprecated_configs, do: ~s|#{key}: System.get_env("#{env_var}")| Logger.warning(""" #{inspect(key)} configuration containing {:system, env_var} tuples for #{inspect(mod)} is deprecated. Configuration with deprecated values: config #{inspect(otp_app)}, #{inspect(mod)}, #{key}: [ #{deprecated_config_lines |> Enum.join(",\r\n ")} ] Move this configuration into config/runtime.exs and replace the {:system, env_var} tuples with System.get_env/1 function calls: config #{inspect(otp_app)}, #{inspect(mod)}, #{key}: [ #{runtime_exs_config_lines |> Enum.join(",\r\n ")} ] """) end end @doc """ Invoked to warm up caches on start and config change. """ def warmup(endpoint) do warmup_persistent(endpoint) try do if manifest = cache_static_manifest(endpoint) do warmup_static(endpoint, manifest) end rescue e -> Logger.error("Could not warm up static assets: #{Exception.message(e)}") end # To prevent a race condition where the socket listener is already started # but the config not warmed up, we run warmup/1 as a child in the supervision # tree. As we don't actually want to start a process, we return :ignore here. :ignore end defp warmup_persistent(endpoint) do url_config = endpoint.config(:url) static_url_config = endpoint.config(:static_url) || url_config struct_url = build_url(endpoint, url_config) host = host_to_binary(url_config[:host] || "localhost") path = empty_string_if_root(url_config[:path] || "/") script_name = String.split(path, "/", trim: true) static_url = build_url(endpoint, static_url_config) |> String.Chars.URI.to_string() static_path = empty_string_if_root(static_url_config[:path] || "/") :persistent_term.put({Phoenix.Endpoint, endpoint}, %{ struct_url: struct_url, url: String.Chars.URI.to_string(struct_url), host: host, path: path, script_name: script_name, static_path: static_path, static_url: static_url }) end defp empty_string_if_root("/"), do: "" defp empty_string_if_root(other), do: other defp build_url(endpoint, url) do https = endpoint.config(:https) http = endpoint.config(:http) {scheme, port} = cond do https -> {"https", https[:port] || 443} http -> {"http", http[:port] || 80} true -> {"http", 80} end scheme = url[:scheme] || scheme host = host_to_binary(url[:host] || "localhost") port = port_to_integer(url[:port] || port) if host =~ ~r"[^:]:\d" do Logger.warning( "url: [host: ...] configuration value #{inspect(host)} for #{inspect(endpoint)} is invalid" ) end %URI{scheme: scheme, port: port, host: host} end defp warmup_static(endpoint, %{"latest" => latest, "digests" => digests}) do Phoenix.Config.put(endpoint, :cache_static_manifest_latest, latest) with_vsn? = !endpoint.config(:cache_manifest_skip_vsn) Enum.each(latest, fn {key, _} -> Phoenix.Config.cache(endpoint, {:__phoenix_static__, "/" <> key}, fn _ -> {:cache, static_cache(digests, Map.get(latest, key), with_vsn?)} end) end) end defp warmup_static(_endpoint, _manifest) do raise ArgumentError, "expected cache manifest to include 'latest' and 'digests' keys" end defp static_cache(digests, value, true) do {"/#{value}?vsn=d", static_integrity(digests[value]["sha512"])} end defp static_cache(digests, value, false) do {"/#{value}", static_integrity(digests[value]["sha512"])} end defp static_integrity(nil), do: nil defp static_integrity(sha), do: "sha512-#{sha}" defp cache_static_manifest(endpoint) do if inner = endpoint.config(:cache_static_manifest) do {app, inner} = case inner do {_, _} = inner -> inner inner when is_binary(inner) -> {endpoint.config(:otp_app), inner} _ -> raise ArgumentError, ":cache_static_manifest must be a binary or a tuple" end outer = Application.app_dir(app, inner) if File.exists?(outer) do outer |> File.read!() |> Phoenix.json_library().decode!() else raise ArgumentError, "could not find static manifest at #{inspect(outer)}. " <> "Run \"mix phx.digest\" after building your static files " <> "or remove the \"cache_static_manifest\" configuration from your config files." end else nil end end defp log_access_url(endpoint, conf) do if Keyword.get(conf, :log_access_url, true) && server?(conf) do Logger.info("Access #{inspect(endpoint)} at #{endpoint.url()}") end end defp browser_open(endpoint, conf) do if Application.get_env(:phoenix, :browser_open, false) && server?(conf) do url = endpoint.url() {cmd, args} = case :os.type() do {:win32, _} -> {"cmd", ["/c", "start", url]} {:unix, :darwin} -> {"open", [url]} {:unix, _} -> {"xdg-open", [url]} end System.cmd(cmd, args) end end end ================================================ FILE: lib/phoenix/endpoint/sync_code_reload_plug.ex ================================================ defmodule Phoenix.Endpoint.SyncCodeReloadPlug do @moduledoc ~S""" Wraps an Endpoint, attempting to sync with Phoenix's code reloader if an exception is raised which indicates that we may be in the middle of a reload. We detect this by looking at the raised exception and seeing if it indicates that the endpoint is not defined. This indicates that the code reloader may be midway through a compile, and that we should attempt to retry the request after the compile has completed. This is also why this must be implemented in a separate module (one that is not recompiled in a typical code reload cycle), since otherwise it may be the case that the endpoint itself is not defined. """ @behaviour Plug def init({endpoint, opts}), do: {endpoint, endpoint.init(opts)} def call(conn, {endpoint, opts}), do: do_call(conn, endpoint, opts, true) defp do_call(conn, endpoint, opts, retry?) do try do endpoint.call(conn, opts) rescue exception in [UndefinedFunctionError] -> case exception do %UndefinedFunctionError{module: ^endpoint} when retry? -> # Sync with the code reloader and retry once Phoenix.CodeReloader.sync() do_call(conn, endpoint, opts, false) exception -> reraise(exception, __STACKTRACE__) end end end end ================================================ FILE: lib/phoenix/endpoint/watcher.ex ================================================ defmodule Phoenix.Endpoint.Watcher do @moduledoc false require Logger def child_spec(args) do %{ id: make_ref(), start: {__MODULE__, :start_link, [args]}, restart: :transient } end def start_link({cmd, args}) do Task.start_link(__MODULE__, :watch, [to_string(cmd), args]) end def watch(_cmd, {mod, fun, args}) do try do apply(mod, fun, args) catch kind, reason -> # The function returned a non-zero exit code. # Sleep for a couple seconds before exiting to # ensure this doesn't hit the supervisor's # max_restarts/max_seconds limit. Process.sleep(2000) :erlang.raise(kind, reason, __STACKTRACE__) end end def watch(cmd, args) when is_list(args) do {args, opts} = Enum.split_while(args, &is_binary(&1)) opts = Keyword.merge([into: IO.stream(:stdio, :line), stderr_to_stdout: true], opts) try do System.cmd(cmd, args, opts) catch :error, :enoent -> relative = Path.relative_to_cwd(cmd) Logger.error( "Could not start watcher #{inspect(relative)} from #{inspect(cd(opts))}, executable does not exist" ) exit(:shutdown) else {_, 0} -> :ok {_, _} -> # System.cmd returned a non-zero exit code # sleep for a couple seconds before exiting to ensure this doesn't # hit the supervisor's max_restarts / max_seconds limit Process.sleep(2000) exit(:watcher_command_error) end end defp cd(opts), do: opts[:cd] || File.cwd!() end ================================================ FILE: lib/phoenix/endpoint.ex ================================================ defmodule Phoenix.Endpoint do @moduledoc ~S""" Defines a Phoenix endpoint. The endpoint is the boundary where all requests to your web application start. It is also the interface your application provides to the underlying web servers. Overall, an endpoint has three responsibilities: * to provide a wrapper for starting and stopping the endpoint as part of a supervision tree * to define an initial plug pipeline for requests to pass through * to host web specific configuration for your application ## Endpoints An endpoint is simply a module defined with the help of `Phoenix.Endpoint`. If you have used the `mix phx.new` generator, an endpoint was automatically generated as part of your application: defmodule YourAppWeb.Endpoint do use Phoenix.Endpoint, otp_app: :your_app # plug ... # plug ... plug YourApp.Router end Endpoints must be explicitly started as part of your application supervision tree. Endpoints are added by default to the supervision tree in generated applications. Endpoints can be added to the supervision tree as follows: children = [ YourAppWeb.Endpoint ] ## Endpoint configuration All endpoints are configured in your application environment. For example: config :your_app, YourAppWeb.Endpoint, secret_key_base: "kjoy3o1zeidquwy1398juxzldjlksahdk3" Endpoint configuration is split into two categories. Compile-time configuration means the configuration is read during compilation and changing it at runtime has no effect. The compile-time configuration is mostly related to error handling. Runtime configuration, instead, is accessed during or after your application is started and can be read through the `c:config/2` function: YourAppWeb.Endpoint.config(:port) YourAppWeb.Endpoint.config(:some_config, :default_value) ### Compile-time configuration Compile-time configuration may be set on `config/dev.exs`, `config/prod.exs` and so on, but has no effect on `config/runtime.exs`: * `:code_reloader` - when `true`, enables code reloading functionality. For the list of code reloader configuration options see `Phoenix.CodeReloader.reload/1`. Keep in mind code reloading is based on the file-system, therefore it is not possible to run two instances of the same app at the same time with code reloading in development, as they will race each other and only one will effectively recompile the files. In such cases, tweak your config files so code reloading is enabled in only one of the apps or set the `MIX_BUILD_PATH` environment variable to give them distinct build directories * `:debug_errors` - when `true`, uses `Plug.Debugger` functionality for debugging failures in the application. Recommended to be set to `true` only in development as it allows listing of the application source code during debugging. Defaults to `false` * `:force_ssl` - ensures no data is ever sent via HTTP, always redirecting to HTTPS. It expects a list of options which are forwarded to `Plug.SSL`. By default it sets the "strict-transport-security" header in HTTPS requests, forcing browsers to always use HTTPS. If an unsafe request (HTTP) is sent, it redirects to the HTTPS version using the `:host` specified in the `:url` configuration. To dynamically redirect to the `host` of the current request, set `:host` in the `:force_ssl` configuration to `nil` ### Runtime configuration The configuration below may be set on `config/dev.exs`, `config/prod.exs` and so on, as well as on `config/runtime.exs`. Typically, if you need to configure them with system environment variables, you set them in `config/runtime.exs`. These options may also be set when starting the endpoint in your supervision tree, such as `{MyApp.Endpoint, options}`. * `:adapter` - which webserver adapter to use for serving web requests. See the "Adapter configuration" section below * `:cache_static_manifest` - a path to a json manifest file that contains static files and their digested version. This is typically set to "priv/static/cache_manifest.json" which is the file automatically generated by `mix phx.digest`. It can be either: a string containing a file system path or a tuple containing the application name and the path within that application. * `:cache_static_manifest_latest` - a map of the static files pointing to their digest version. This is automatically loaded from `cache_static_manifest` on boot. However, if you have your own static handling mechanism, you may want to set this value explicitly. This is used by projects such as `LiveView` to detect if the client is running on the latest version of all assets. * `:cache_manifest_skip_vsn` - when true, skips the appended query string "?vsn=d" when generating paths to static assets. This query string is used by `Plug.Static` to set long expiry dates, therefore, you should set this option to true only if you are not using `Plug.Static` to serve assets, for example, if you are using a CDN. If you are setting this option, you should also consider passing `--no-vsn` to `mix phx.digest`. Defaults to `false`. * `:check_origin` - configure the default `:check_origin` setting for transports. See `socket/3` for options. Defaults to `true`. * `:secret_key_base` - a secret key used as a base to generate secrets for encrypting and signing data. For example, cookies and tokens are signed by default, but they may also be encrypted if desired. Defaults to `nil` as it must be set per application * `:server` - when `true`, starts the web server when the endpoint supervision tree starts. Defaults to `false`. The `mix phx.server` task automatically sets this to `true` * `:url` - configuration for generating URLs throughout the app. Accepts the `:host`, `:scheme`, `:path` and `:port` options. All keys except `:path` can be changed at runtime. Defaults to: [host: "localhost", path: "/"] The `:port` option requires either an integer or string. The `:host` option requires a string. The `:scheme` option accepts `"http"` and `"https"` values. Default value is inferred from top level `:http` or `:https` option. It is useful when hosting Phoenix behind a load balancer or reverse proxy and terminating SSL there. The `:path` option can be used to override root path. Useful when hosting Phoenix behind a reverse proxy with URL rewrite rules * `:static_url` - configuration for generating URLs for static files. It will fallback to `url` if no option is provided. Accepts the same options as `url` * `:watchers` - a set of watchers to run alongside your server. It expects a list of tuples containing the executable and its arguments. Watchers are guaranteed to run in the application directory, but only when the server is enabled (unless `:force_watchers` configuration is set to `true`). For example, the watcher below will run the "watch" mode of the webpack build tool when the server starts. You can configure it to whatever build tool or command you want: [ node: [ "node_modules/webpack/bin/webpack.js", "--mode", "development", "--watch", "--watch-options-stdin" ] ] The `:cd` and `:env` options can be given at the end of the list to customize the watcher: [node: [..., cd: "assets", env: [{"TAILWIND_MODE", "watch"}]]] A watcher can also be a module-function-args tuple that will be invoked accordingly: [another: {Mod, :fun, [arg1, arg2]}] When `false`, watchers can be disabled. * `:force_watchers` - when `true`, forces your watchers to start even when the `:server` option is set to `false`. * `:live_reload` - configuration for the live reload option. Configuration requires a `:patterns` option which should be a list of file patterns to watch. When these files change, it will trigger a reload. live_reload: [ url: "ws://localhost:4000", patterns: [ ~r"priv/static/(?!uploads/).*(js|css|png|jpeg|jpg|gif|svg)$", ~r"lib/app_web/(live|views)/.*(ex)$", ~r"lib/app_web/templates/.*(eex)$" ] ] * `:pubsub_server` - the name of the pubsub server to use in channels and via the Endpoint broadcast functions. The PubSub server is typically started in your supervision tree. * `:render_errors` - responsible for rendering templates whenever there is a failure in the application. For example, if the application crashes with a 500 error during a HTML request, `render("500.html", assigns)` will be called in the view given to `:render_errors`. A `:formats` list can be provided to specify a module per format to handle error rendering. Example: [formats: [html: MyApp.ErrorHTML], layout: false, log: :debug] * `:log_access_url` - log the access url once the server boots Note that you can also store your own configurations in the Phoenix.Endpoint. For example, [Phoenix LiveView](https://hexdocs.pm/phoenix_live_view) expects its own configuration under the `:live_view` key. In such cases, you should consult the documentation of the respective projects. ### Adapter configuration Phoenix allows you to choose which webserver adapter to use. Newly generated applications created via the `phx.new` Mix task use the [`Bandit`](https://github.com/mtrudel/bandit) webserver via the `Bandit.PhoenixAdapter` adapter. If not otherwise specified via the `adapter` option Phoenix will fall back to the `Phoenix.Endpoint.Cowboy2Adapter` for backwards compatibility with applications generated prior to Phoenix 1.7.8. Both adapters can be configured in a similar manner using the following two top-level options: * `:http` - the configuration for the HTTP server. It accepts all options as defined by either [`Bandit`](https://hexdocs.pm/bandit/Bandit.html#t:options/0) or [`Plug.Cowboy`](https://hexdocs.pm/plug_cowboy/) depending on your choice of adapter. Defaults to `false` * `:https` - the configuration for the HTTPS server. It accepts all options as defined by either [`Bandit`](https://hexdocs.pm/bandit/Bandit.html#t:options/0) or [`Plug.Cowboy`](https://hexdocs.pm/plug_cowboy/) depending on your choice of adapter. Defaults to `false` In addition, the connection draining can be configured for the Cowboy webserver via the following top-level option (this is not required for Bandit as it has connection draining built-in): * `:drainer` - a drainer process waits for any on-going request to finish during application shutdown. It accepts the `:shutdown` and `:check_interval` options as defined by `Plug.Cowboy.Drainer`. Note the draining does not terminate any existing connection, it simply waits for them to finish. Socket connections run their own drainer before this one is invoked. That's because sockets are stateful and can be gracefully notified, which allows us to stagger them over a longer period of time. See the documentation for `socket/3` for more information ## Endpoint API In the previous section, we have used the `c:config/2` function that is automatically generated in your endpoint. Here's a list of all the functions that are automatically defined in your endpoint: * for handling paths and URLs: `c:struct_url/0`, `c:url/0`, `c:path/1`, `c:static_url/0`,`c:static_path/1`, and `c:static_integrity/1` * for gathering runtime information about the address and port the endpoint is running on: `c:server_info/1` * for broadcasting to channels: `c:broadcast/3`, `c:broadcast!/3`, `c:broadcast_from/4`, `c:broadcast_from!/4`, `c:local_broadcast/3`, and `c:local_broadcast_from/4` * for configuration: `c:start_link/1`, `c:config/2`, and `c:config_change/2` * as required by the `Plug` behaviour: `c:Plug.init/1` and `c:Plug.call/2` """ @type topic :: String.t() @type event :: String.t() @type msg :: map | {:binary, binary} # Configuration @doc """ Starts the endpoint supervision tree. Starts endpoint's configuration cache and possibly the servers for handling requests. """ @callback start_link(keyword) :: Supervisor.on_start() @doc """ Access the endpoint configuration given by key. """ @callback config(key :: atom, default :: term) :: term @doc """ Reload the endpoint configuration on application upgrades. """ @callback config_change(changed :: term, removed :: term) :: term # Paths and URLs @doc """ Generates the endpoint base URL, but as a `URI` struct. """ @callback struct_url() :: URI.t() @doc """ Generates the endpoint base URL without any path information. """ @callback url() :: String.t() @doc """ Generates the path information when routing to this endpoint. """ @callback path(path :: String.t()) :: String.t() @doc """ Generates the static URL without any path information. """ @callback static_url() :: String.t() @doc """ Generates a route to a static file in `priv/static`. """ @callback static_path(path :: String.t()) :: String.t() @doc """ Generates an integrity hash to a static file in `priv/static`. """ @callback static_integrity(path :: String.t()) :: String.t() | nil @doc """ Generates a two item tuple containing the `static_path` and `static_integrity`. """ @callback static_lookup(path :: String.t()) :: {String.t(), String.t()} | {String.t(), nil} @doc """ Returns the script name from the :url configuration. """ @callback script_name() :: [String.t()] @doc """ Returns the host from the :url configuration. """ @callback host() :: String.t() # Server information @doc """ Returns the address and port that the server is running on """ @callback server_info(Plug.Conn.scheme()) :: {:ok, {:inet.ip_address(), :inet.port_number()} | :inet.returned_non_ip_address()} | {:error, term()} # Channels @doc """ Subscribes the caller to the given topic. See `Phoenix.PubSub.subscribe/3` for options. """ @callback subscribe(topic, opts :: Keyword.t()) :: :ok | {:error, term} @doc """ Unsubscribes the caller from the given topic. """ @callback unsubscribe(topic) :: :ok | {:error, term} @doc """ Broadcasts a `msg` as `event` in the given `topic` to all nodes. """ @callback broadcast(topic, event, msg) :: :ok | {:error, term} @doc """ Broadcasts a `msg` as `event` in the given `topic` to all nodes. Raises in case of failures. """ @callback broadcast!(topic, event, msg) :: :ok @doc """ Broadcasts a `msg` from the given `from` as `event` in the given `topic` to all nodes. """ @callback broadcast_from(from :: pid, topic, event, msg) :: :ok | {:error, term} @doc """ Broadcasts a `msg` from the given `from` as `event` in the given `topic` to all nodes. Raises in case of failures. """ @callback broadcast_from!(from :: pid, topic, event, msg) :: :ok @doc """ Broadcasts a `msg` as `event` in the given `topic` within the current node. """ @callback local_broadcast(topic, event, msg) :: :ok @doc """ Broadcasts a `msg` from the given `from` as `event` in the given `topic` within the current node. """ @callback local_broadcast_from(from :: pid, topic, event, msg) :: :ok @doc false defmacro __using__(opts) do quote do @behaviour Phoenix.Endpoint unquote(config(opts)) unquote(pubsub()) unquote(plug()) unquote(server()) end end defp config(opts) do quote do @otp_app unquote(opts)[:otp_app] || raise("endpoint expects :otp_app to be given") # Compile-time configuration checking # This ensures that if a compile-time configuration is overwritten at runtime the application won't boot. var!(code_reloading?) = Application.compile_env(@otp_app, [__MODULE__, :code_reloader], false) var!(debug_errors?) = Application.compile_env(@otp_app, [__MODULE__, :debug_errors], false) var!(force_ssl) = Application.compile_env(@otp_app, [__MODULE__, :force_ssl]) # Avoid unused variable warnings _ = var!(code_reloading?) _ = var!(force_ssl) end end defp pubsub() do quote generated: true do def subscribe(topic, opts \\ []) when is_binary(topic) do Phoenix.PubSub.subscribe(pubsub_server!(), topic, opts) end def unsubscribe(topic) do Phoenix.PubSub.unsubscribe(pubsub_server!(), topic) end def broadcast_from(from, topic, event, msg) do Phoenix.Channel.Server.broadcast_from(pubsub_server!(), from, topic, event, msg) end def broadcast_from!(from, topic, event, msg) do Phoenix.Channel.Server.broadcast_from!(pubsub_server!(), from, topic, event, msg) end def broadcast(topic, event, msg) do Phoenix.Channel.Server.broadcast(pubsub_server!(), topic, event, msg) end def broadcast!(topic, event, msg) do Phoenix.Channel.Server.broadcast!(pubsub_server!(), topic, event, msg) end def local_broadcast(topic, event, msg) do Phoenix.Channel.Server.local_broadcast(pubsub_server!(), topic, event, msg) end def local_broadcast_from(from, topic, event, msg) do Phoenix.Channel.Server.local_broadcast_from(pubsub_server!(), from, topic, event, msg) end defp pubsub_server! do config(:pubsub_server) || raise ArgumentError, "no :pubsub_server configured for #{inspect(__MODULE__)}" end end end defp plug() do quote location: :keep do use Plug.Builder, init_mode: Phoenix.plug_init_mode() import Phoenix.Endpoint Module.register_attribute(__MODULE__, :phoenix_sockets, accumulate: true) if force_ssl = Phoenix.Endpoint.__force_ssl__(__MODULE__, var!(force_ssl)) do plug Plug.SSL, force_ssl end if var!(debug_errors?) do logo = "data:image/svg+xml;base64,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" use Plug.Debugger, otp_app: @otp_app, banner: {Phoenix.Endpoint.RenderErrors, :__debugger_banner__, []}, style: [ primary: "#EB532D", dark: [ primary: "#FF6B4A", logo: logo ], logo: logo ] end plug :socket_dispatch # Compile after the debugger so we properly wrap it. @before_compile Phoenix.Endpoint end end defp server() do quote location: :keep, unquote: false do @doc """ Returns the child specification to start the endpoint under a supervision tree. """ def child_spec(opts) do %{ id: __MODULE__, start: {__MODULE__, :start_link, [opts]}, type: :supervisor } end @doc """ Starts the endpoint supervision tree. All other options are merged into the endpoint configuration. """ def start_link(opts \\ []) do Phoenix.Endpoint.Supervisor.start_link(@otp_app, __MODULE__, opts) end @doc """ Returns the endpoint configuration for `key` Returns `default` if the key does not exist. """ def config(key, default \\ nil) do case :ets.lookup(__MODULE__, key) do [{^key, val}] -> val [] -> default end end @doc """ Reloads the configuration given the application environment changes. """ def config_change(changed, removed) do Phoenix.Endpoint.Supervisor.config_change(__MODULE__, changed, removed) end defp persistent!() do :persistent_term.get({Phoenix.Endpoint, __MODULE__}, nil) || raise "could not find persistent term for endpoint #{inspect(__MODULE__)}. Make sure your endpoint is started and note you cannot access endpoint functions at compile-time" end @doc """ Generates the endpoint base URL without any path information. It uses the configuration under `:url` to generate such. """ def url, do: persistent!().url @doc """ Generates the static URL without any path information. It uses the configuration under `:static_url` to generate such. It falls back to `:url` if `:static_url` is not set. """ def static_url, do: persistent!().static_url @doc """ Generates the endpoint base URL but as a `URI` struct. It uses the configuration under `:url` to generate such. Useful for manipulating the URL data and passing it to URL helpers. """ def struct_url, do: persistent!().struct_url @doc """ Returns the host for the given endpoint. """ def host, do: persistent!().host @doc """ Generates the path information when routing to this endpoint. """ def path(path), do: persistent!().path <> path @doc """ Generates the script name. """ def script_name, do: persistent!().script_name @doc """ Generates a route to a static file in `priv/static`. """ def static_path(path) do prefix = persistent!().static_path case :binary.split(path, "#") do [path, fragment] -> prefix <> elem(static_lookup(path), 0) <> "#" <> fragment [path] -> prefix <> elem(static_lookup(path), 0) end end @doc """ Generates a base64-encoded cryptographic hash (sha512) to a static file in `priv/static`. Meant to be used for Subresource Integrity with CDNs. """ def static_integrity(path), do: elem(static_lookup(path), 1) @doc """ Returns a two item tuple with the first item being the `static_path` and the second item being the `static_integrity`. """ def static_lookup(path) do Phoenix.Config.cache( __MODULE__, {:__phoenix_static__, path}, &Phoenix.Endpoint.Supervisor.static_lookup(&1, path) ) end @doc """ Returns the address and port that the server is running on """ def server_info(scheme), do: config(:adapter).server_info(__MODULE__, scheme) end end @doc false def __force_ssl__(module, force_ssl) do if force_ssl do Keyword.put_new(force_ssl, :host, {module, :host, []}) end end @doc false defmacro __before_compile__(%{module: module}) do sockets = Module.get_attribute(module, :phoenix_sockets) dispatches = for {path, socket, socket_opts} <- sockets, {path, plug, conn_ast, plug_opts} <- socket_paths(module, path, socket, socket_opts) do quote do defp do_socket_dispatch(unquote(path), conn) do halt(unquote(plug).call(unquote(conn_ast), unquote(Macro.escape(plug_opts)))) end end end quote do defoverridable call: 2 # Inline render errors so we set the endpoint before calling it. def call(conn, opts) do conn = %{conn | script_name: script_name(), secret_key_base: config(:secret_key_base)} conn = Plug.Conn.put_private(conn, :phoenix_endpoint, __MODULE__) try do super(conn, opts) rescue e in Plug.Conn.WrapperError -> %{conn: conn, kind: kind, reason: reason, stack: stack} = e Phoenix.Endpoint.RenderErrors.__catch__( conn, kind, reason, stack, config(:render_errors) ) catch kind, reason -> stack = __STACKTRACE__ Phoenix.Endpoint.RenderErrors.__catch__( conn, kind, reason, stack, config(:render_errors) ) end end @doc false def __sockets__, do: unquote(Macro.escape(sockets)) @doc false def socket_dispatch(%{path_info: path} = conn, _opts), do: do_socket_dispatch(path, conn) unquote(dispatches) defp do_socket_dispatch(_path, conn), do: conn end end defp socket_paths(endpoint, path, socket, opts) do paths = [] common_config = [ :path, :serializer, :transport_log, :check_origin, :check_csrf, :code_reloader, :connect_info, :auth_token, :log ] websocket = opts |> Keyword.get(:websocket, true) |> maybe_validate_keys( common_config ++ [ :timeout, :max_frame_size, :fullsweep_after, :compress, :subprotocols, :error_handler ] ) longpoll = opts |> Keyword.get(:longpoll, false) |> maybe_validate_keys( common_config ++ [ :window_ms, :pubsub_timeout_ms, :crypto ] ) paths = if websocket do websocket = put_auth_token(websocket, opts[:auth_token]) config = Phoenix.Socket.Transport.load_config(websocket, Phoenix.Transports.WebSocket) plug_init = {endpoint, socket, config} {conn_ast, match_path} = socket_path(path, config) [{match_path, Phoenix.Transports.WebSocket, conn_ast, plug_init} | paths] else paths end paths = if longpoll do longpoll = put_auth_token(longpoll, opts[:auth_token]) config = Phoenix.Socket.Transport.load_config(longpoll, Phoenix.Transports.LongPoll) plug_init = {endpoint, socket, config} {conn_ast, match_path} = socket_path(path, config) [{match_path, Phoenix.Transports.LongPoll, conn_ast, plug_init} | paths] else paths end paths end defp put_auth_token(true, enabled), do: [auth_token: enabled] defp put_auth_token(opts, enabled), do: Keyword.put(opts, :auth_token, enabled) defp socket_path(path, config) do end_path_fragment = Keyword.fetch!(config, :path) {vars, path} = String.split(path <> "/" <> end_path_fragment, "/", trim: true) |> Enum.join("/") |> Plug.Router.Utils.build_path_match() conn_ast = if vars == [] do quote do conn end else params = for var <- vars, param = Atom.to_string(var), not match?("_" <> _, param), do: {param, Macro.var(var, nil)} quote do params = %{unquote_splicing(params)} %{conn | path_params: params, params: params} end end {conn_ast, path} end defp maybe_validate_keys(opts, keys) when is_list(opts), do: Keyword.validate!(opts, keys) defp maybe_validate_keys(other, _), do: other ## API @doc """ Defines a websocket/longpoll mount-point for a `socket`. It expects a `path`, a `socket` module, and a set of options. The socket module is typically defined with `Phoenix.Socket`. Both websocket and longpolling connections are supported out of the box. ## Options * `:websocket` - controls the websocket configuration. Defaults to `true`. May be false or a keyword list of options. See ["Common configuration"](#socket/3-common-configuration) and ["WebSocket configuration"](#socket/3-websocket-configuration) for the whole list * `:longpoll` - controls the longpoll configuration. Defaults to `false`. May be true or a keyword list of options. See ["Common configuration"](#socket/3-common-configuration) and ["Longpoll configuration"](#socket/3-longpoll-configuration) for the whole list * `:drainer` - a keyword list or a custom MFA function returning a keyword list, for example: {MyAppWeb.Socket, :drainer_configuration, []} configuring how to drain sockets on application shutdown. The goal is to notify all channels (and LiveViews) clients to reconnect. The supported options are: * `:batch_size` - How many clients to notify at once in a given batch. Defaults to 10000. * `:batch_interval` - The amount of time in milliseconds given for a batch to terminate. Defaults to 2000ms. * `:shutdown` - The maximum amount of time in milliseconds allowed to drain all batches. Defaults to 30000ms. * `:log` - the log level for drain actions. Defaults the `:log` option passed to `use Phoenix.Socket` or `:info`. Set it to `false` to disable logging. For example, if you have 150k connections, the default values will split them into 15 batches of 10k connections. Each batch takes 2000ms before the next batch starts. In this case, we will do everything right under the maximum shutdown time of 30000ms. Therefore, as you increase the number of connections, remember to adjust the shutdown accordingly. Finally, after the socket drainer runs, the lower level HTTP/HTTPS connection drainer will still run, and apply to all connections. Set it to `false` to disable draining. * `auth_token` - a boolean that enables the use of the channels client's auth_token option. The exact token exchange mechanism depends on the transport: * the websocket transport, this enables a token to be passed through the `Sec-WebSocket-Protocol` header. * the longpoll transport, this allows the token to be passed through the `Authorization` header. The token is available in the `connect_info` as `:auth_token`. Custom transports might implement their own mechanism. You can also pass the options below on `use Phoenix.Socket`. The values specified here override the value in `use Phoenix.Socket`. ## Examples socket "/ws", MyApp.UserSocket socket "/ws/admin", MyApp.AdminUserSocket, longpoll: true, websocket: [compress: true] ## Path params It is possible to include variables in the path, these will be available in the `params` that are passed to the socket. socket "/ws/:user_id", MyApp.UserSocket, websocket: [path: "/project/:project_id"] ## Common configuration The configuration below can be given to both `:websocket` and `:longpoll` keys: * `:path` - the path to use for the transport. Will default to the transport name ("/websocket" or "/longpoll") * `:serializer` - a list of serializers for messages. See `Phoenix.Socket` for more information * `:transport_log` - if the transport layer itself should log and, if so, the level * `:check_origin` - if the transport should check the origin of requests when the `origin` header is present. May be `true`, `false`, a list of URIs that are allowed, or a function provided as MFA tuple. Defaults to `:check_origin` setting at endpoint configuration. If `true`, the header is checked against `:host` in `YourAppWeb.Endpoint.config(:url)[:host]`. If `false` and you do not validate the session in your socket, your app is vulnerable to Cross-Site WebSocket Hijacking (CSWSH) attacks. Only use in development, when the host is truly unknown or when serving clients that do not send the `origin` header, such as mobile apps. You can also specify a list of explicitly allowed origins. Each origin may include scheme, host, and port. Wildcards are supported. check_origin: [ "https://example.com", "//another.com:888", "//*.other.com" ] Or to accept any origin matching the request connection's host, port, and scheme: check_origin: :conn Or a custom MFA function: check_origin: {MyAppWeb.Auth, :my_check_origin?, []} The MFA is invoked with the request `%URI{}` as the first argument, followed by arguments in the MFA list, and must return a boolean. * `:check_csrf` - if the transport should perform CSRF check. To avoid "Cross-Site WebSocket Hijacking", you must have at least one of `check_origin` and `check_csrf` enabled. If you set both to `false`, Phoenix will raise, but it is still possible to disable both by passing a custom MFA to `check_origin`. In such cases, it is your responsibility to ensure at least one of them is enabled. Defaults to `true` * `:code_reloader` - enable or disable the code reloader. Defaults to your endpoint configuration * `:connect_info` - a list of keys that represent data to be copied from the transport to be made available in the user socket `connect/3` callback. See the "Connect info" subsection for valid keys ### Connect info The valid keys are: * `:peer_data` - the result of `Plug.Conn.get_peer_data/1` * `:trace_context_headers` - a list of all trace context headers. Supported headers are defined by the [W3C Trace Context Specification](https://www.w3.org/TR/trace-context-1/). These headers are necessary for libraries such as [OpenTelemetry](https://opentelemetry.io/) to extract trace propagation information to know this request is part of a larger trace in progress. * `:x_headers` - all request headers that have an "x-" prefix * `:uri` - a `%URI{}` with information from the conn * `:user_agent` - the value of the "user-agent" request header * `{:session, session_config}` - the session information from `Plug.Conn`. The `session_config` is typically an exact copy of the arguments given to `Plug.Session`. In order to validate the session, the "_csrf_token" must be given as request parameter when connecting the socket with the value of `URI.encode_www_form(Plug.CSRFProtection.get_csrf_token())`. The CSRF token request parameter can be modified via the `:csrf_token_key` option. Additionally, `session_config` may be a MFA, such as `{MyAppWeb.Auth, :get_session_config, []}`, to allow loading config in runtime. Arbitrary keywords may also appear following the above valid keys, which is useful for passing custom connection information to the socket. For example: ``` socket "/socket", AppWeb.UserSocket, websocket: [ connect_info: [:peer_data, :trace_context_headers, :x_headers, :uri, session: [store: :cookie]] ] ``` With arbitrary keywords: ``` socket "/socket", AppWeb.UserSocket, websocket: [ connect_info: [:uri, custom_value: "abcdef"] ] ``` > #### Where are my headers? {: .tip} > > Phoenix only gives you limited access to the connection headers for security > reasons. WebSockets are cross-domain, which means that, when a user "John Doe" > visits a malicious website, the malicious website can open up a WebSocket > connection to your application, and the browser will gladly submit John Doe's > authentication/cookie information. If you were to accept this information as is, > the malicious website would have full control of a WebSocket connection to your > application, authenticated on John Doe's behalf. > > To safe-guard your application, Phoenix limits and validates the connection > information your socket can access. This means your application is safe from > these attacks, but you can't access cookies and other headers in your socket. > You may access the session stored in the connection via the `:connect_info` > option, provided you also pass a csrf token when connecting over WebSocket. ## Websocket configuration The following configuration applies only to `:websocket`. * `:timeout` - the timeout for keeping websocket connections open after it last received data, defaults to 60_000ms * `:max_frame_size` - the maximum allowed frame size in bytes, defaults to "infinity" * `:fullsweep_after` - the maximum number of garbage collections before forcing a fullsweep for the socket process. You can set it to `0` to force more frequent cleanups of your websocket transport processes. Setting this option requires Erlang/OTP 24 * `:compress` - whether to enable per message compression on all data frames, defaults to false * `:subprotocols` - a list of supported websocket subprotocols. Used for handshake `Sec-WebSocket-Protocol` response header, defaults to nil. For example: subprotocols: ["sip", "mqtt"] * `:error_handler` - custom error handler for connection errors. If `c:Phoenix.Socket.connect/3` returns an `{:error, reason}` tuple, the error handler will be called with the error reason. For WebSockets, the error handler must be a MFA tuple that receives a `Plug.Conn`, the error reason, and returns a `Plug.Conn` with a response. For example: socket "/socket", MySocket, websocket: [ error_handler: {MySocket, :handle_error, []} ] and a `{:error, :rate_limit}` return may be handled on `MySocket` as: def handle_error(conn, :rate_limit), do: Plug.Conn.send_resp(conn, 429, "Too many requests") ## Longpoll configuration The following configuration applies only to `:longpoll`: * `:window_ms` - how long the client can wait for new messages in its poll request in milliseconds (ms). Defaults to `10_000`. * `:pubsub_timeout_ms` - how long a request can wait for the pubsub layer to respond in milliseconds (ms). Defaults to `2000`. * `:crypto` - options for verifying and signing the token, accepted by `Phoenix.Token`. By default tokens are valid for 2 weeks """ defmacro socket(path, module, opts \\ []) do module = Macro.expand(module, %{__CALLER__ | function: {:socket_dispatch, 2}}) quote do @phoenix_sockets {unquote(path), unquote(module), unquote(opts)} end end @doc false @deprecated "Phoenix.Endpoint.instrument/4 is deprecated and has no effect. Use :telemetry instead" defmacro instrument(_endpoint_or_conn_or_socket, _event, _runtime, _fun) do :ok end @doc """ Checks if Endpoint's web server has been configured to start. * `otp_app` - The OTP app running the endpoint, for example `:my_app` * `endpoint` - The endpoint module, for example `MyAppWeb.Endpoint` ## Examples iex> Phoenix.Endpoint.server?(:my_app, MyAppWeb.Endpoint) true """ def server?(otp_app, endpoint) when is_atom(otp_app) and is_atom(endpoint) do Phoenix.Endpoint.Supervisor.server?(otp_app, endpoint) end end ================================================ FILE: lib/phoenix/exceptions.ex ================================================ defmodule Phoenix.NotAcceptableError do @moduledoc """ Raised when one of the `accept*` headers is not accepted by the server. This exception is commonly raised by `Phoenix.Controller.accepts/2` which negotiates the media types the server is able to serve with the contents the client is able to render. If you are seeing this error, you should check if you are listing the desired formats in your `:accepts` plug or if you are setting the proper accept header in the client. The exception contains the acceptable mime types in the `accepts` field. """ defexception message: nil, accepts: [], plug_status: 406 end defmodule Phoenix.MissingParamError do @moduledoc """ Raised when a key is expected to be present in the request parameters, but is not. This exception is raised by `Phoenix.Controller.scrub_params/2` which: * Checks to see if the required_key is present (can be empty) * Changes all empty parameters to nils ("" -> nil) If you are seeing this error, you should handle the error and surface it to the end user. It means that there is a parameter missing from the request. """ defexception [:message, plug_status: 400] def exception([key: value]) do msg = "expected key #{inspect value} to be present in params, " <> "please send the expected key or adapt your scrub_params/2 call" %Phoenix.MissingParamError{message: msg} end end defmodule Phoenix.ActionClauseError do exception_keys = FunctionClauseError.__struct__() |> Map.keys() |> Kernel.--([:__exception__, :__struct__]) defexception exception_keys @impl true def message(exception) do exception |> Map.put(:__struct__, FunctionClauseError) |> FunctionClauseError.message() end @impl true def blame(exception, stacktrace) do {exception, stacktrace} = exception |> Map.put(:__struct__, FunctionClauseError) |> FunctionClauseError.blame(stacktrace) exception = Map.put(exception, :__struct__, __MODULE__) {exception, stacktrace} end end defimpl Plug.Exception, for: Phoenix.ActionClauseError do def status(_), do: 400 def actions(_), do: [] end ================================================ FILE: lib/phoenix/flash.ex ================================================ defmodule Phoenix.Flash do @moduledoc """ Provides shared flash access. """ @doc """ Gets the key from the map of flash data. ## Examples ```heex
<%= Phoenix.Flash.get(@flash, :info) %>
<%= Phoenix.Flash.get(@flash, :error) %>
``` """ def get(%mod{}, key) when is_atom(key) or is_binary(key) do raise ArgumentError, """ expected a map of flash data, but got a %#{inspect(mod)}{} Use the @flash assign set by the :fetch_flash plug instead: <%= Phoenix.Flash.get(@flash, :#{key}) %> """ end def get(%{} = flash, key) when is_atom(key) or is_binary(key) do Map.get(flash, to_string(key)) end end ================================================ FILE: lib/phoenix/logger.ex ================================================ defmodule Phoenix.Logger do @moduledoc """ Instrumenter to handle logging of various instrumentation events. ## Instrumentation Phoenix uses the `:telemetry` library for instrumentation. The following events are published by Phoenix with the following measurements and metadata: * `[:phoenix, :endpoint, :init]` - dispatched by `Phoenix.Endpoint` after your Endpoint supervision tree successfully starts * Measurement: `%{system_time: system_time}` * Metadata: `%{pid: pid(), config: Keyword.t(), module: module(), otp_app: atom()}` * Disable logging: This event is not logged * `[:phoenix, :endpoint, :start]` - dispatched by `Plug.Telemetry` in your endpoint, usually after code reloading * Measurement: `%{system_time: system_time}` * Metadata: `%{conn: Plug.Conn.t, options: Keyword.t}` * Options: `%{log: Logger.level | false}` * Disable logging: In your endpoint `plug Plug.Telemetry, ..., log: Logger.level | false` * Configure log level dynamically: `plug Plug.Telemetry, ..., log: {Mod, Fun, Args}` * `[:phoenix, :endpoint, :stop]` - dispatched by `Plug.Telemetry` in your endpoint whenever the response is sent * Measurement: `%{duration: native_time}` * Metadata: `%{conn: Plug.Conn.t, options: Keyword.t}` * Options: `%{log: Logger.level | false}` * Disable logging: In your endpoint `plug Plug.Telemetry, ..., log: Logger.level | false` * Configure log level dynamically: `plug Plug.Telemetry, ..., log: {Mod, Fun, Args}` * `[:phoenix, :router_dispatch, :start]` - dispatched by `Phoenix.Router` before dispatching to a matched route * Measurement: `%{system_time: System.system_time}` * Metadata: `%{conn: Plug.Conn.t, route: binary, plug: module, plug_opts: term, path_params: map, pipe_through: [atom], log: Logger.level | false}` * Disable logging: Pass `log: false` to the router macro, for example: `get("/page", PageController, :index, log: false)` * Configure log level dynamically: `get("/page", PageController, :index, log: {Mod, Fun, Args})` * `[:phoenix, :router_dispatch, :exception]` - dispatched by `Phoenix.Router` after exceptions on dispatching a route * Measurement: `%{duration: native_time}` * Metadata: `%{conn: Plug.Conn.t, kind: :throw | :error | :exit, reason: term(), stacktrace: Exception.stacktrace()}` * Disable logging: This event is not logged * `[:phoenix, :router_dispatch, :stop]` - dispatched by `Phoenix.Router` after successfully dispatching a matched route * Measurement: `%{duration: native_time}` * Metadata: `%{conn: Plug.Conn.t, route: binary, plug: module, plug_opts: term, path_params: map, pipe_through: [atom], log: Logger.level | false}` * Disable logging: This event is not logged * `[:phoenix, :error_rendered]` - dispatched at the end of an error view being rendered * Measurement: `%{duration: native_time}` * Metadata: `%{conn: Plug.Conn.t, status: Plug.Conn.status, kind: Exception.kind, reason: term, stacktrace: Exception.stacktrace}` * Disable logging: Set `render_errors: [log: false]` on your endpoint configuration * `[:phoenix, :socket_connected]` - dispatched by `Phoenix.Socket`, at the end of a socket connection * Measurement: `%{duration: native_time}` * Metadata: `%{endpoint: atom, transport: atom, params: term, connect_info: map, vsn: binary, user_socket: atom, result: :ok | :error, serializer: atom, log: Logger.level | false}` * Disable logging: `use Phoenix.Socket, log: false` or `socket "/foo", MySocket, websocket: [log: false]` in your endpoint * `[:phoenix, :socket_drain]` - dispatched by `Phoenix.Socket` when using the `:drainer` option * Measurement: `%{count: integer, total: integer, index: integer, rounds: integer}` * Metadata: `%{endpoint: atom, socket: atom, intervasl: integer, log: Logger.level | false}` * Disable logging: `use Phoenix.Socket, log: false` in your endpoint or pass `:log` option in the `:drainer` option * `[:phoenix, :channel_joined]` - dispatched at the end of a channel join * Measurement: `%{duration: native_time}` * Metadata: `%{result: :ok | :error, params: term, socket: Phoenix.Socket.t}` * Disable logging: This event cannot be disabled * `[:phoenix, :channel_handled_in]` - dispatched at the end of a channel handle in * Measurement: `%{duration: native_time}` * Metadata: `%{event: binary, params: term, socket: Phoenix.Socket.t}` * Disable logging: This event cannot be disabled To see an example of how Phoenix LiveDashboard uses these events to create metrics, visit . ## Parameter filtering When logging parameters, Phoenix can filter out sensitive parameters such as passwords and tokens. Parameters to be filtered can be added via the `:filter_parameters` option: config :phoenix, :filter_parameters, ["password", "secret"] With the configuration above, Phoenix will filter any parameter that contains the terms `password` or `secret`. The match is case sensitive. Phoenix's default is `["password"]`. Phoenix can filter all parameters by default and selectively keep parameters. This can be configured like so: config :phoenix, :filter_parameters, {:keep, ["id", "order"]} With the configuration above, Phoenix will filter all parameters, except those that match exactly `id` or `order`. If a kept parameter matches, all parameters nested under that one will also be kept. ## Dynamic log level In some cases you may wish to set the log level dynamically on a per-request basis. To do so, set the `:log` option to a tuple, `{Mod, Fun, Args}`. The `Plug.Conn.t()` for the request will be prepended to the provided list of arguments. When invoked, your function must return a [`Logger.level()`](`t:Logger.level()/0`) or `false` to disable logging for the request. For example, in your Endpoint you might do something like this: # lib/my_app_web/endpoint.ex plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint], log: {__MODULE__, :log_level, []} # Disables logging for routes like /status/* def log_level(%{path_info: ["status" | _]}), do: false def log_level(_), do: :info ## Disabling When you are using custom logging system it is not always desirable to enable `#{inspect(__MODULE__)}` by default. You can always disable this in general by: config :phoenix, :logger, false """ require Logger @doc false def install do handlers = %{ [:phoenix, :endpoint, :start] => &__MODULE__.phoenix_endpoint_start/4, [:phoenix, :endpoint, :stop] => &__MODULE__.phoenix_endpoint_stop/4, [:phoenix, :router_dispatch, :start] => &__MODULE__.phoenix_router_dispatch_start/4, [:phoenix, :error_rendered] => &__MODULE__.phoenix_error_rendered/4, [:phoenix, :socket_connected] => &__MODULE__.phoenix_socket_connected/4, [:phoenix, :socket_drain] => &__MODULE__.phoenix_socket_drain/4, [:phoenix, :channel_joined] => &__MODULE__.phoenix_channel_joined/4, [:phoenix, :channel_handled_in] => &__MODULE__.phoenix_channel_handled_in/4 } for {key, fun} <- handlers do :telemetry.attach({__MODULE__, key}, key, fun, :ok) end end @doc false def duration(duration) do duration = System.convert_time_unit(duration, :native, :microsecond) if duration > 1000 do [duration |> div(1000) |> Integer.to_string(), "ms"] else [Integer.to_string(duration), "µs"] end end @doc false def compile_filter({:compiled, _key, _value} = filter), do: filter def compile_filter({:discard, params}), do: compile_discard(params) def compile_filter({:keep, params}), do: {:keep, params} def compile_filter(params), do: compile_discard(params) defp compile_discard([]) do {:compiled, [], []} end defp compile_discard(params) when is_list(params) or is_binary(params) do key_match = :binary.compile_pattern(params) value_match = params |> List.wrap() |> Enum.map(&(&1 <> "=")) |> :binary.compile_pattern() {:compiled, key_match, value_match} end @doc false def filter_values(values, filter \\ Application.get_env(:phoenix, :filter_parameters, [])) do case compile_filter(filter) do {:compiled, key_match, value_match} -> discard_values(values, key_match, value_match) {:keep, match} -> keep_values(values, match) end end defp discard_values(%{__struct__: mod} = struct, _key_match, _value_match) when is_atom(mod) do struct end defp discard_values(%{} = map, key_match, value_match) do Enum.into(map, %{}, fn {k, v} -> cond do is_binary(k) and String.contains?(k, key_match) -> {k, "[FILTERED]"} is_binary(v) and String.contains?(v, value_match) -> {k, "[FILTERED]"} true -> {k, discard_values(v, key_match, value_match)} end end) end defp discard_values([_ | _] = list, key_match, value_match) do Enum.map(list, &discard_values(&1, key_match, value_match)) end defp discard_values(other, _key_match, _value_match), do: other defp keep_values(%{__struct__: mod}, _match) when is_atom(mod), do: "[FILTERED]" defp keep_values(%{} = map, match) do Enum.into(map, %{}, fn {k, v} -> if is_binary(k) and k in match do {k, v} else {k, keep_values(v, match)} end end) end defp keep_values([_ | _] = list, match) do Enum.map(list, &keep_values(&1, match)) end defp keep_values(_other, _match), do: "[FILTERED]" defp log_level(nil, _conn), do: :info defp log_level(level, _conn) when is_atom(level), do: level defp log_level({mod, fun, args}, conn) when is_atom(mod) and is_atom(fun) and is_list(args) do apply(mod, fun, [conn | args]) end ## Event: [:phoenix, :endpoint, *] @doc false def phoenix_endpoint_start(_, _, %{conn: conn} = metadata, _) do case log_level(metadata[:options][:log], conn) do false -> :ok level -> Logger.log(level, fn -> %{method: method, request_path: request_path} = conn [method, ?\s, request_path] end) end end @doc false def phoenix_endpoint_stop(_, %{duration: duration}, %{conn: conn} = metadata, _) do case log_level(metadata[:options][:log], conn) do false -> :ok level -> Logger.log(level, fn -> %{status: status, state: state} = conn status = status_to_string(status) [connection_type(state), ?\s, status, " in ", duration(duration)] end) end end defp connection_type(:set_chunked), do: "Chunked" defp connection_type(_), do: "Sent" ## Event: [:phoenix, :error_rendered] @doc false def phoenix_error_rendered(_, _, %{log: false}, _), do: :ok def phoenix_error_rendered(_, _, %{log: level, status: status, kind: kind, reason: reason}, _) do Logger.log(level, fn -> [ "Converted ", Atom.to_string(kind), ?\s, error_banner(kind, reason), " to ", status_to_string(status), " response" ] end) end defp status_to_string(status) do status |> Plug.Conn.Status.code() |> Integer.to_string() end defp error_banner(:error, %type{}), do: inspect(type) defp error_banner(_kind, reason), do: inspect(reason) ## Event: [:phoenix, :router_dispatch, :start] @doc false def phoenix_router_dispatch_start(_, _, %{log: false}, _), do: :ok def phoenix_router_dispatch_start(_, _, metadata, _) do %{log: level, conn: conn, plug: plug} = metadata level = log_level(level, conn) Logger.log(level, fn -> %{ pipe_through: pipe_through, plug_opts: plug_opts } = metadata log_mfa = case metadata[:mfa] do {mod, fun, arity} -> mfa(mod, fun, arity) _ when is_atom(plug_opts) -> mfa(plug, plug_opts, 2) _ -> inspect(plug) end [ "Processing with ", log_mfa, ?\n, " Parameters: ", params(conn.params), ?\n, " Pipelines: ", inspect(pipe_through) ] end) end defp mfa(mod, fun, arity), do: [inspect(mod), ?., Atom.to_string(fun), ?/, arity + ?0] defp params(%Plug.Conn.Unfetched{}), do: "[UNFETCHED]" defp params(params), do: params |> filter_values() |> inspect() ## Event: [:phoenix, :socket_connected] @doc false def phoenix_socket_connected(_, _, %{log: false}, _), do: :ok def phoenix_socket_connected(_, %{duration: duration}, %{log: level} = meta, _) do Logger.log(level, fn -> %{ transport: transport, params: params, user_socket: user_socket, result: result, serializer: serializer } = meta [ connect_result(result), inspect(user_socket), " in ", duration(duration), "\n Transport: ", inspect(transport), "\n Serializer: ", inspect(serializer), "\n Parameters: ", inspect(filter_values(params)) ] end) end defp connect_result(:ok), do: "CONNECTED TO " defp connect_result(:error), do: "REFUSED CONNECTION TO " @doc false def phoenix_socket_drain(_, _, %{log: false}, _), do: :ok def phoenix_socket_drain( _, %{count: count, total: total, index: index, rounds: rounds}, %{log: level} = meta, _ ) do Logger.log(level, fn -> %{socket: socket, interval: interval} = meta [ "DRAINING #{count} of #{total} total connection(s) for socket ", inspect(socket), " every #{interval}ms - ", "round #{index} of #{rounds}" ] end) end ## Event: [:phoenix, :channel_joined] @doc false def phoenix_channel_joined(_, %{duration: duration}, %{socket: socket} = metadata, _) do channel_log(:log_join, socket, fn -> %{result: result, params: params} = metadata [ join_result(result), socket.topic, " in ", duration(duration), "\n Parameters: ", inspect(filter_values(params)) ] end) end defp join_result(:ok), do: "JOINED " defp join_result(:error), do: "REFUSED JOIN " ## Event: [:phoenix, :channel_handle_in] @doc false def phoenix_channel_handled_in(_, %{duration: duration}, %{socket: socket} = metadata, _) do channel_log(:log_handle_in, socket, fn -> %{event: event, params: params} = metadata [ "HANDLED ", event, " INCOMING ON ", socket.topic, " (", inspect(socket.channel), ") in ", duration(duration), "\n Parameters: ", inspect(filter_values(params)) ] end) end defp channel_log(_log_option, %{topic: "phoenix" <> _}, _fun), do: :ok defp channel_log(log_option, %{private: private}, fun) do if level = Map.get(private, log_option) do Logger.log(level, fun) end end end ================================================ FILE: lib/phoenix/naming.ex ================================================ defmodule Phoenix.Naming do @moduledoc """ Conveniences for inflecting and working with names in Phoenix. """ @doc """ Extracts the resource name from an alias. ## Examples iex> Phoenix.Naming.resource_name(MyApp.User) "user" iex> Phoenix.Naming.resource_name(MyApp.UserView, "View") "user" """ @spec resource_name(String.Chars.t, String.t) :: String.t def resource_name(alias, suffix \\ "") do alias |> to_string() |> Module.split() |> List.last() |> unsuffix(suffix) |> underscore() end @doc """ Removes the given suffix from the name if it exists. ## Examples iex> Phoenix.Naming.unsuffix("MyApp.User", "View") "MyApp.User" iex> Phoenix.Naming.unsuffix("MyApp.UserView", "View") "MyApp.User" """ @spec unsuffix(String.t, String.t) :: String.t def unsuffix(value, suffix) do string = to_string(value) suffix_size = byte_size(suffix) prefix_size = byte_size(string) - suffix_size case string do <> -> prefix _ -> string end end @doc """ Converts a string to underscore case. ## Examples iex> Phoenix.Naming.underscore("MyApp") "my_app" In general, `underscore` can be thought of as the reverse of `camelize`, however, in some cases formatting may be lost: Phoenix.Naming.underscore "SAPExample" #=> "sap_example" Phoenix.Naming.camelize "sap_example" #=> "SapExample" """ @spec underscore(String.t) :: String.t def underscore(value), do: Macro.underscore(value) defp to_lower_char(char) when char in ?A..?Z, do: char + 32 defp to_lower_char(char), do: char @doc """ Converts a string to camel case. Takes an optional `:lower` flag to return lowerCamelCase. ## Examples iex> Phoenix.Naming.camelize("my_app") "MyApp" iex> Phoenix.Naming.camelize("my_app", :lower) "myApp" In general, `camelize` can be thought of as the reverse of `underscore`, however, in some cases formatting may be lost: Phoenix.Naming.underscore "SAPExample" #=> "sap_example" Phoenix.Naming.camelize "sap_example" #=> "SapExample" """ @spec camelize(String.t) :: String.t def camelize(value), do: Macro.camelize(value) @spec camelize(String.t, :lower) :: String.t def camelize("", :lower), do: "" def camelize(<>, :lower) do camelize(t, :lower) end def camelize(<> = value, :lower) do <<_first, rest :: binary>> = camelize(value) <> <> rest end @doc """ Converts an attribute/form field into its humanize version. ## Examples iex> Phoenix.Naming.humanize(:username) "Username" iex> Phoenix.Naming.humanize(:created_at) "Created at" iex> Phoenix.Naming.humanize("user_id") "User" """ @spec humanize(atom | String.t) :: String.t def humanize(atom) when is_atom(atom), do: humanize(Atom.to_string(atom)) def humanize(bin) when is_binary(bin) do bin = if String.ends_with?(bin, "_id") do binary_part(bin, 0, byte_size(bin) - 3) else bin end bin |> String.replace("_", " ") |> String.capitalize end end ================================================ FILE: lib/phoenix/param.ex ================================================ defprotocol Phoenix.Param do @moduledoc ~S""" A protocol that converts data structures into URL parameters. This protocol is used by `Phoenix.VerifiedRoutes` and other parts of the Phoenix stack. For example, when you write: ~p"/user/#{@user}/edit" Phoenix knows how to extract the `:id` from `@user` thanks to this protocol. (Deprecated URL helpers, e.g. `user_path(conn, :edit, @user)`, work the same way.) By default, Phoenix implements this protocol for integers, binaries, atoms, and structs. For structs, a key `:id` is assumed, but you may provide a specific implementation. The term `nil` cannot be converted to param. ## Custom parameters In order to customize the parameter for any struct, one can simply implement this protocol. For example for a `Date` struct: defimpl Phoenix.Param, for: Date do def to_param(date) do Date.to_string(date) end end However, for convenience, this protocol can also be derivable. For example: defmodule User do @derive Phoenix.Param defstruct [:id, :username] end By default, the derived implementation will also use the `:id` key. In case the user does not contain an `:id` key, the key can be specified with an option: defmodule User do @derive {Phoenix.Param, key: :username} defstruct [:username] end will automatically use `:username` in URLs. When using Ecto, you must call `@derive` before your `schema` call: @derive {Phoenix.Param, key: :username} schema "users" do """ @fallback_to_any true @spec to_param(term) :: String.t() def to_param(term) end defimpl Phoenix.Param, for: Integer do def to_param(int), do: Integer.to_string(int) end defimpl Phoenix.Param, for: Float do def to_param(float), do: Float.to_string(float) end defimpl Phoenix.Param, for: BitString do def to_param(bin) when is_binary(bin), do: bin end defimpl Phoenix.Param, for: Atom do def to_param(nil) do raise ArgumentError, "cannot convert nil to param" end def to_param(atom) do Atom.to_string(atom) end end defimpl Phoenix.Param, for: Map do def to_param(map) do raise ArgumentError, "maps cannot be converted to_param. A struct was expected, got: #{inspect(map)}" end end defimpl Phoenix.Param, for: Any do defmacro __deriving__(module, struct, options) do key = Keyword.get(options, :key, :id) unless Map.has_key?(struct, key) do raise ArgumentError, "cannot derive Phoenix.Param for struct #{inspect(module)} " <> "because it does not have key #{inspect(key)}. Please pass " <> "the :key option when deriving" end quote do defimpl Phoenix.Param, for: unquote(module) do def to_param(%{unquote(key) => nil}) do raise ArgumentError, "cannot convert #{inspect(unquote(module))} to param, " <> "key #{inspect(unquote(key))} contains a nil value" end def to_param(%{unquote(key) => key}) when is_integer(key), do: Integer.to_string(key) def to_param(%{unquote(key) => key}) when is_binary(key), do: key def to_param(%{unquote(key) => key}), do: Phoenix.Param.to_param(key) end end end def to_param(%{id: nil}) do raise ArgumentError, "cannot convert struct to param, key :id contains a nil value" end def to_param(%{id: id}) when is_integer(id), do: Integer.to_string(id) def to_param(%{id: id}) when is_binary(id), do: id def to_param(%{id: id}), do: Phoenix.Param.to_param(id) def to_param(map) when is_map(map) do raise ArgumentError, "structs expect an :id key when converting to_param or a custom implementation " <> "of the Phoenix.Param protocol (read Phoenix.Param docs for more information), " <> "got: #{inspect(map)}" end def to_param(data) do raise Protocol.UndefinedError, protocol: @protocol, value: data end end ================================================ FILE: lib/phoenix/presence.ex ================================================ defmodule Phoenix.Presence do @moduledoc """ Provides Presence tracking to processes and channels. This behaviour provides presence features such as fetching presences for a given topic, as well as handling diffs of join and leave events as they occur in real-time. Using this module defines a supervisor and a module that implements the `Phoenix.Tracker` behaviour that uses `Phoenix.PubSub` to broadcast presence updates. In case you want to use only a subset of the functionality provided by `Phoenix.Presence`, such as tracking processes but without broadcasting updates, we recommend that you look at the `Phoenix.Tracker` functionality from the `phoenix_pubsub` project. ## Example Usage Start by defining a presence module within your application which uses `Phoenix.Presence` and provide the `:otp_app` which holds your configuration, as well as the `:pubsub_server`. defmodule MyAppWeb.Presence do use Phoenix.Presence, otp_app: :my_app, pubsub_server: MyApp.PubSub end The `:pubsub_server` must point to an existing pubsub server running in your application, which is included by default as `MyApp.PubSub` for new applications. Next, add the new supervisor to your supervision tree in `lib/my_app/application.ex`. It must be after the PubSub child and before the endpoint: children = [ ... {Phoenix.PubSub, name: MyApp.PubSub}, MyAppWeb.Presence, MyAppWeb.Endpoint ] Once added, presences can be tracked in your channel after joining: defmodule MyAppWeb.MyChannel do use MyAppWeb, :channel alias MyAppWeb.Presence def join("some:topic", _params, socket) do send(self(), :after_join) {:ok, assign(socket, :user_id, ...)} end def handle_info(:after_join, socket) do {:ok, _} = Presence.track(socket, socket.assigns.user_id, %{ online_at: inspect(System.system_time(:second)) }) push(socket, "presence_state", Presence.list(socket)) {:noreply, socket} end end In the example above, `Presence.track` is used to register this channel's process as a presence for the socket's user ID, with a map of metadata. Next, the current presence information for the socket's topic is pushed to the client as a `"presence_state"` event. Finally, a diff of presence join and leave events will be sent to the client as they happen in real-time with the "presence_diff" event. The diff structure will be a map of `:joins` and `:leaves` of the form: %{ joins: %{"123" => %{metas: [%{status: "away", phx_ref: ...}]}}, leaves: %{"456" => %{metas: [%{status: "online", phx_ref: ...}]}} }, See `c:list/1` for more information on the presence data structure. ## Custom dispatcher It's possible to customize the dispatcher module used to broadcast. By default, `Phoenix.Channel.Server` is used, which is the same dispatcher used by channels. To customize the dispatcher, pass the `:dispatcher` option when using `Phoenix.Presence`: use Phoenix.Presence, otp_app: :my_app, pubsub_server: MyApp.PubSub, dispatcher: MyApp.CustomDispatcher See `m:Phoenix.PubSub#module-custom-dispatching` for more information on custom dispatchers. ## Fetching Presence Information Presence metadata should be minimized and used to store small, ephemeral state, such as a user's "online" or "away" status. More detailed information, such as user details that need to be fetched from the database, can be achieved by overriding the `c:fetch/2` function. The `c:fetch/2` callback is triggered when using `c:list/1` and on every update, and it serves as a mechanism to fetch presence information a single time, before broadcasting the information to all channel subscribers. This prevents N query problems and gives you a single place to group isolated data fetching to extend presence metadata. The function must return a map of data matching the outlined Presence data structure, including the `:metas` key, but can extend the map of information to include any additional information. For example: def fetch(_topic, presences) do users = presences |> Map.keys() |> Accounts.get_users_map() for {key, %{metas: metas}} <- presences, into: %{} do {key, %{metas: metas, user: users[String.to_integer(key)]}} end end Where `Account.get_users_map/1` could be implemented like: def get_users_map(ids) do query = from u in User, where: u.id in ^ids, select: {u.id, u} query |> Repo.all() |> Enum.into(%{}) end The `fetch/2` function above fetches all users from the database who have registered presences for the given topic. The presences information is then extended with a `:user` key of the user's information, while maintaining the required `:metas` field from the original presence data. ## Using Elixir as a Presence Client Presence is great for external clients, such as JavaScript applications, but it can also be used from an Elixir client process to keep track of presence changes as they happen on the server. This can be accomplished by implementing the optional [`init/1`](`c:init/1`) and [`handle_metas/4`](`c:handle_metas/4`) callbacks on your presence module. For example, the following callback receives presence metadata changes, and broadcasts to other Elixir processes about users joining and leaving: defmodule MyApp.Presence do use Phoenix.Presence, otp_app: :my_app, pubsub_server: MyApp.PubSub def init(_opts) do {:ok, %{}} # user-land state end def handle_metas(topic, %{joins: joins, leaves: leaves}, presences, state) do # fetch existing presence information for the joined users and broadcast the # event to all subscribers for {user_id, presence} <- joins do user_data = %{user: presence.user, metas: Map.fetch!(presences, user_id)} msg = {MyApp.PresenceClient, {:join, user_data}} Phoenix.PubSub.local_broadcast(MyApp.PubSub, topic, msg) end # fetch existing presence information for the left users and broadcast the # event to all subscribers for {user_id, presence} <- leaves do metas = case Map.fetch(presences, user_id) do {:ok, presence_metas} -> presence_metas :error -> [] end user_data = %{user: presence.user, metas: metas} msg = {MyApp.PresenceClient, {:leave, user_data}} Phoenix.PubSub.local_broadcast(MyApp.PubSub, topic, msg) end {:ok, state} end end The `handle_metas/4` callback receives the topic, presence diff, current presences for the topic with their metadata, and any user-land state accumulated from init and subsequent `handle_metas/4` calls. In our example implementation, we walk the `:joins` and `:leaves` in the diff, and populate a complete presence from our known presence information. Then we broadcast to the local node subscribers about user joins and leaves. ## Testing with Presence Every time the `fetch` callback is invoked, it is done from a separate process. Given those processes run asynchronously, it is often necessary to guarantee they have been shutdown at the end of every test. This can be done by using ExUnit's `on_exit` hook plus `fetchers_pids` function: on_exit(fn -> for pid <- MyAppWeb.Presence.fetchers_pids() do ref = Process.monitor(pid) assert_receive {:DOWN, ^ref, _, _, _}, 1000 end end) """ @type presences :: %{String.t() => %{metas: [map()]}} @type presence :: %{key: String.t(), meta: map()} @type topic :: String.t() @doc """ Track a channel's process as a presence. Tracked presences are grouped by `key`, cast as a string. For example, to group each user's channels together, use user IDs as keys. Each presence can be associated with a map of metadata to store small, ephemeral state, such as a user's online status. To store detailed information, see `c:fetch/2`. ## Example alias MyApp.Presence def handle_info(:after_join, socket) do {:ok, _} = Presence.track(socket, socket.assigns.user_id, %{ online_at: inspect(System.system_time(:second)) }) {:noreply, socket} end """ @callback track(socket :: Phoenix.Socket.t(), key :: String.t(), meta :: map()) :: {:ok, ref :: binary()} | {:error, reason :: term()} @doc """ Track an arbitrary process as a presence. Same with `track/3`, except track any process by `topic` and `key`. """ @callback track(pid, topic, key :: String.t(), meta :: map()) :: {:ok, ref :: binary()} | {:error, reason :: term()} @doc """ Stop tracking a channel's process. """ @callback untrack(socket :: Phoenix.Socket.t(), key :: String.t()) :: :ok @doc """ Stop tracking a process. """ @callback untrack(pid, topic, key :: String.t()) :: :ok @doc """ Update a channel presence's metadata. Replace a presence's metadata by passing a new map or a function that takes the current map and returns a new one. """ @callback update( socket :: Phoenix.Socket.t(), key :: String.t(), meta :: map() | (map() -> map()) ) :: {:ok, ref :: binary()} | {:error, reason :: term()} @doc """ Update a process presence's metadata. Same as `update/3`, but with an arbitrary process. """ @callback update(pid, topic, key :: String.t(), meta :: map() | (map() -> map())) :: {:ok, ref :: binary()} | {:error, reason :: term()} @doc """ Returns presences for a socket/topic. ## Presence data structure The presence information is returned as a map with presences grouped by key, cast as a string, and accumulated metadata, with the following form: %{key => %{metas: [%{phx_ref: ..., ...}, ...]}} For example, imagine a user with id `123` online from two different devices, as well as a user with id `456` online from just one device. The following presence information might be returned: %{"123" => %{metas: [%{status: "away", phx_ref: ...}, %{status: "online", phx_ref: ...}]}, "456" => %{metas: [%{status: "online", phx_ref: ...}]}} The keys of the map will usually point to a resource ID. The value will contain a map with a `:metas` key containing a list of metadata for each resource. Additionally, every metadata entry will contain a `:phx_ref` key which can be used to uniquely identify metadata for a given key. In the event that the metadata was previously updated, a `:phx_ref_prev` key will be present containing the previous `:phx_ref` value. """ @callback list(socket_or_topic :: Phoenix.Socket.t() | topic) :: presences @doc """ Returns the map of presence metadata for a socket/topic-key pair. ## Examples Uses the same data format as each presence in `c:list/1`, but only returns metadata for the presences under a topic and key pair. For example, a user with key `"user1"`, connected to the same chat room `"room:1"` from two devices, could return: iex> MyPresence.get_by_key("room:1", "user1") [%{name: "User 1", metas: [%{device: "Desktop"}, %{device: "Mobile"}]}] Like `c:list/1`, the presence metadata is passed to the `fetch` callback of your presence module to fetch any additional information. """ @callback get_by_key(Phoenix.Socket.t() | topic, key :: String.t()) :: [presence] @doc """ Extend presence information with additional data. When `c:list/1` is used to list all presences of the given `topic`, this callback is triggered once to modify the result before it is broadcasted to all channel subscribers. This avoids N query problems and provides a single place to extend presence metadata. You must return a map of data matching the original result, including the `:metas` key, but can extend the map to include any additional information. The default implementation simply passes `presences` through unchanged. ## Example def fetch(_topic, presences) do query = from u in User, where: u.id in ^Map.keys(presences), select: {u.id, u} users = query |> Repo.all() |> Enum.into(%{}) for {key, %{metas: metas}} <- presences, into: %{} do {key, %{metas: metas, user: users[key]}} end end """ @callback fetch(topic, presences) :: presences @doc """ Initializes the presence client state. Invoked when your presence module starts, allows dynamically providing initial state for handling presence metadata. """ @callback init(state :: term) :: {:ok, new_state :: term} @doc """ Receives presence metadata changes. """ @callback handle_metas(topic :: String.t(), diff :: map(), presences :: map(), state :: term) :: {:ok, term} @optional_callbacks init: 1, handle_metas: 4 defmacro __using__(opts) do quote location: :keep, bind_quoted: [opts: opts] do @behaviour Phoenix.Presence @opts opts @task_supervisor Module.concat(__MODULE__, "TaskSupervisor") _ = opts[:otp_app] || raise "use Phoenix.Presence expects :otp_app to be given" # User defined def fetch(_topic, presences), do: presences defoverridable fetch: 2 # Private def child_spec(opts) do opts = Keyword.merge(@opts, opts) %{ id: __MODULE__, start: {Phoenix.Presence, :start_link, [__MODULE__, @task_supervisor, opts]}, type: :supervisor } end # API def track(%Phoenix.Socket{} = socket, key, meta) do track(socket.channel_pid, socket.topic, key, meta) end def track(pid, topic, key, meta) do Phoenix.Tracker.track(__MODULE__, pid, topic, key, meta) end def untrack(%Phoenix.Socket{} = socket, key) do untrack(socket.channel_pid, socket.topic, key) end def untrack(pid, topic, key) do Phoenix.Tracker.untrack(__MODULE__, pid, topic, key) end def update(%Phoenix.Socket{} = socket, key, meta) do update(socket.channel_pid, socket.topic, key, meta) end def update(pid, topic, key, meta) do Phoenix.Tracker.update(__MODULE__, pid, topic, key, meta) end def list(%Phoenix.Socket{topic: topic}), do: list(topic) def list(topic), do: Phoenix.Presence.list(__MODULE__, topic) def get_by_key(%Phoenix.Socket{topic: topic}, key), do: get_by_key(topic, key) def get_by_key(topic, key), do: Phoenix.Presence.get_by_key(__MODULE__, topic, key) def fetchers_pids(), do: Task.Supervisor.children(@task_supervisor) end end defmodule Tracker do @moduledoc false use Phoenix.Tracker def start_link({module, task_supervisor, opts}) do pubsub_server = opts[:pubsub_server] || raise "use Phoenix.Presence expects :pubsub_server to be given" dispatcher = opts[:dispatcher] || Phoenix.Channel.Server Phoenix.Tracker.start_link( __MODULE__, {module, task_supervisor, pubsub_server, dispatcher}, opts ) end def init(state), do: Phoenix.Presence.init(state) def handle_diff(diff, state), do: Phoenix.Presence.handle_diff(diff, state) def handle_info(msg, state), do: Phoenix.Presence.handle_info(msg, state) end @doc false def start_link(module, task_supervisor, opts) do otp_app = opts[:otp_app] opts = opts |> Keyword.merge(Application.get_env(otp_app, module, [])) |> Keyword.put(:name, module) children = [ {Task.Supervisor, name: task_supervisor}, {Tracker, {module, task_supervisor, opts}} ] sup_opts = [ strategy: :rest_for_one, name: Module.concat(module, "Supervisor") ] Supervisor.start_link(children, sup_opts) end @doc false def init({module, task_supervisor, pubsub_server, dispatcher}) do state = %{ module: module, task_supervisor: task_supervisor, pubsub_server: pubsub_server, topics: %{}, tasks: :queue.new(), current_task: nil, client_state: nil, dispatcher: dispatcher } client_state = if function_exported?(module, :handle_metas, 4) do unless function_exported?(module, :init, 1) do raise ArgumentError, """ missing #{inspect(module)}.init/1 callback for client state When you implement the handle_metas/4 callback, you must also implement init/1. For example, add the following to #{inspect(module)}: def init(_opts), do: {:ok, %{}} """ end case module.init(%{}) do {:ok, client_state} -> client_state other -> raise ArgumentError, """ expected #{inspect(module)}.init/1 to return {:ok, state}, got: #{inspect(other)} """ end end {:ok, %{state | client_state: client_state}} end @doc false def handle_diff(diff, state) do {:ok, async_merge(state, diff)} end @doc false def handle_info({task_ref, {:phoenix, ref, computed_diffs}}, state) do %{current_task: current_task} = state {^ref, %Task{ref: ^task_ref} = task} = current_task Task.shutdown(task) Enum.each(computed_diffs, fn {topic, presence_diff} -> broadcast = %Phoenix.Socket.Broadcast{ topic: topic, event: "presence_diff", payload: presence_diff } Phoenix.PubSub.local_broadcast(state.pubsub_server, topic, broadcast, state.dispatcher) end) new_state = if function_exported?(state.module, :handle_metas, 4) do do_handle_metas(state, computed_diffs) else state end {:noreply, next_task(new_state)} end @doc false def list(module, topic) do grouped = module |> Phoenix.Tracker.list(topic) |> group() module.fetch(topic, grouped) end @doc false def get_by_key(module, topic, key) do string_key = to_string(key) case Phoenix.Tracker.get_by_key(module, topic, key) do [] -> [] [_ | _] = pid_metas -> metas = Enum.map(pid_metas, fn {_pid, meta} -> meta end) %{^string_key => fetched_metas} = module.fetch(topic, %{string_key => %{metas: metas}}) fetched_metas end end @doc false def group(presences) do presences |> Enum.reverse() |> Enum.reduce(%{}, fn {key, meta}, acc -> Map.update(acc, to_string(key), %{metas: [meta]}, fn %{metas: metas} -> %{metas: [meta | metas]} end) end) end defp send_continue(%Task{} = task, ref), do: send(task.pid, {ref, :continue}) defp next_task(state) do case :queue.out(state.tasks) do {{:value, {ref, %Task{} = next}}, remaining_tasks} -> send_continue(next, ref) %{state | current_task: {ref, next}, tasks: remaining_tasks} {:empty, _} -> %{state | current_task: nil, tasks: :queue.new()} end end defp do_handle_metas(state, computed_diffs) do Enum.reduce(computed_diffs, state, fn {topic, presence_diff}, acc -> updated_topics = merge_diff(acc.topics, topic, presence_diff) topic_presences = case Map.fetch(updated_topics, topic) do {:ok, presences} -> presences :error -> %{} end case acc.module.handle_metas(topic, presence_diff, topic_presences, acc.client_state) do {:ok, updated_client_state} -> %{acc | topics: updated_topics, client_state: updated_client_state} other -> raise ArgumentError, """ expected #{inspect(acc.module)}.handle_metas/4 to return {:ok, new_state}. got: #{inspect(other)} """ end end) end defp async_merge(state, diff) do %{module: module} = state ref = make_ref() new_task = Task.Supervisor.async(state.task_supervisor, fn -> computed_diffs = Enum.map(diff, fn {topic, {joins, leaves}} -> joins = module.fetch(topic, Phoenix.Presence.group(joins)) leaves = module.fetch(topic, Phoenix.Presence.group(leaves)) {topic, %{joins: joins, leaves: leaves}} end) receive do {^ref, :continue} -> {:phoenix, ref, computed_diffs} end end) if state.current_task do %{state | tasks: :queue.in({ref, new_task}, state.tasks)} else send_continue(new_task, ref) %{state | current_task: {ref, new_task}} end end defp merge_diff(topics, topic, %{leaves: leaves, joins: joins} = _diff) do # add new topic if needed updated_topics = if Map.has_key?(topics, topic) do topics else add_new_topic(topics, topic) end # merge diff into topics {updated_topics, _topic} = Enum.reduce(joins, {updated_topics, topic}, &handle_join/2) {updated_topics, _topic} = Enum.reduce(leaves, {updated_topics, topic}, &handle_leave/2) # if no more presences for given topic, remove topic if topic_presences_count(updated_topics, topic) == 0 do remove_topic(updated_topics, topic) else updated_topics end end defp handle_join({joined_key, presence}, {topics, topic}) do joined_metas = Map.get(presence, :metas, []) {add_new_presence_or_metas(topics, topic, joined_key, joined_metas), topic} end defp handle_leave({left_key, presence}, {topics, topic}) do {remove_presence_or_metas(topics, topic, left_key, presence), topic} end defp add_new_presence_or_metas( topics, topic, key, new_metas ) do topic_presences = topics[topic] updated_topic = case Map.fetch(topic_presences, key) do # existing presence, add new metas {:ok, existing_metas} -> remaining_metas = new_metas -- existing_metas updated_metas = existing_metas ++ remaining_metas Map.put(topic_presences, key, updated_metas) # there are no presences for that key :error -> Map.put_new(topic_presences, key, new_metas) end Map.put(topics, topic, updated_topic) end defp remove_presence_or_metas( topics, topic, key, deleted_metas ) do topic_presences = topics[topic] presence_metas = Map.get(topic_presences, key, []) remaining_metas = presence_metas -- Map.get(deleted_metas, :metas, []) updated_topic = case remaining_metas do [] -> Map.delete(topic_presences, key) _ -> Map.put(topic_presences, key, remaining_metas) end Map.put(topics, topic, updated_topic) end defp add_new_topic(topics, topic) do Map.put_new(topics, topic, %{}) end defp remove_topic(topics, topic) do Map.delete(topics, topic) end defp topic_presences_count(topics, topic) do map_size(topics[topic]) end end ================================================ FILE: lib/phoenix/router/console_formatter.ex ================================================ defmodule Phoenix.Router.ConsoleFormatter do @moduledoc false @doc """ Format the routes for printing. """ @socket_verb "WS" @longpoll_verbs ["GET", "POST"] def format(router, endpoint \\ nil) do routes = router.formatted_routes([]) column_widths = calculate_column_widths(router, routes, endpoint) IO.iodata_to_binary([ Enum.map(routes, &format_route(&1, router, column_widths)), format_endpoint(endpoint, column_widths) ]) end defp format_endpoint(nil, _router), do: "" defp format_endpoint(endpoint, widths) do case endpoint.__sockets__() do [] -> "" sockets -> Enum.map(sockets, fn socket -> [format_websocket(socket, widths), format_longpoll(socket, widths)] end) end end defp format_websocket({_path, Phoenix.LiveReloader.Socket, _opts}, _), do: "" defp format_websocket({path, module, opts}, widths) do if opts[:websocket] != false do {verb_len, path_len, route_name_len} = widths String.duplicate(" ", route_name_len) <> " " <> String.pad_trailing(@socket_verb, verb_len) <> " " <> String.pad_trailing(path <> "/websocket", path_len) <> " " <> inspect(module) <> "\n" else "" end end defp format_longpoll({_path, Phoenix.LiveReloader.Socket, _opts}, _), do: "" defp format_longpoll({path, module, opts}, widths) do if opts[:longpoll] != false do for method <- @longpoll_verbs, into: "" do {verb_len, path_len, route_name_len} = widths String.duplicate(" ", route_name_len) <> " " <> String.pad_trailing(method, verb_len) <> " " <> String.pad_trailing(path <> "/longpoll", path_len) <> " " <> inspect(module) <> "\n" end else "" end end defp calculate_column_widths(router, routes, endpoint) do sockets = (endpoint && endpoint.__sockets__()) || [] widths = Enum.reduce(routes, {0, 0, 0}, fn route, acc -> %{verb: verb, path: path, helper: helper} = route verb = verb_name(verb) {verb_len, path_len, route_name_len} = acc route_name = route_name(router, helper) {max(verb_len, String.length(verb)), max(path_len, String.length(path)), max(route_name_len, String.length(route_name))} end) Enum.reduce(sockets, widths, fn {path, _mod, opts}, acc -> {verb_len, path_len, route_name_len} = acc verb_length = socket_verbs(opts) |> Enum.map(&String.length/1) |> Enum.max(&>=/2, fn -> 0 end) {max(verb_len, verb_length), max(path_len, String.length(path <> "/websocket")), route_name_len} end) end defp format_route(route, router, column_widths) do %{ verb: verb, path: path, label: label } = route verb = verb_name(verb) route_name = route_name(router, Map.get(route, :helper)) {verb_len, path_len, route_name_len} = column_widths String.pad_leading(route_name, route_name_len) <> " " <> String.pad_trailing(verb, verb_len) <> " " <> String.pad_trailing(path, path_len) <> " " <> label <> "\n" end defp route_name(_router, nil), do: "" defp route_name(router, name) do if router.__helpers__() do name <> "_path" else "" end end defp verb_name(verb), do: verb |> to_string() |> String.upcase() defp socket_verbs(socket_opts) do if socket_opts[:longpoll] != false do [@socket_verb | @longpoll_verbs] else [@socket_verb] end end end ================================================ FILE: lib/phoenix/router/helpers.ex ================================================ defmodule Phoenix.Router.Helpers do # Module that generates the routing helpers. @moduledoc false alias Phoenix.Router.Route alias Plug.Conn @doc """ Generates the helper module for the given environment and routes. """ def define(env, routes) do # Ignore any route without helper or forwards. routes = Enum.reject(routes, fn {route, _exprs} -> is_nil(route.helper) or route.kind == :forward end) trailing_slash? = Enum.any?(routes, fn {route, _} -> route.trailing_slash? end) groups = Enum.group_by(routes, fn {route, _exprs} -> route.helper end) impls = for {_helper, helper_routes} <- groups, {_, [{route, exprs} | _]} <- helper_routes |> Enum.group_by(fn {route, exprs} -> [length(exprs.binding) | route.plug_opts] end) |> Enum.sort(), do: defhelper(route, exprs) catch_all = Enum.map(groups, &defhelper_catch_all/1) defhelper = quote generated: true, unquote: false do defhelper = fn helper, vars, opts, bins, segs, trailing_slash? -> def unquote(:"#{helper}_path")( conn_or_endpoint, unquote(Macro.escape(opts)), unquote_splicing(vars) ) do unquote(:"#{helper}_path")( conn_or_endpoint, unquote(Macro.escape(opts)), unquote_splicing(vars), [] ) end def unquote(:"#{helper}_path")( conn_or_endpoint, unquote(Macro.escape(opts)), unquote_splicing(vars), params ) when is_list(params) or is_map(params) do path( conn_or_endpoint, segments( unquote(segs), params, unquote(bins), unquote(trailing_slash?), {unquote(helper), unquote(Macro.escape(opts)), unquote(Enum.map(vars, &Macro.to_string/1))} ) ) end def unquote(:"#{helper}_url")( conn_or_endpoint, unquote(Macro.escape(opts)), unquote_splicing(vars) ) do unquote(:"#{helper}_url")( conn_or_endpoint, unquote(Macro.escape(opts)), unquote_splicing(vars), [] ) end def unquote(:"#{helper}_url")( conn_or_endpoint, unquote(Macro.escape(opts)), unquote_splicing(vars), params ) when is_list(params) or is_map(params) do url(conn_or_endpoint) <> unquote(:"#{helper}_path")( conn_or_endpoint, unquote(Macro.escape(opts)), unquote_splicing(vars), params ) end end end defcatch_all = quote generated: true, unquote: false do defcatch_all = fn helper, binding_lengths, params_lengths, routes -> for length <- binding_lengths do binding = List.duplicate({:_, [], nil}, length) arity = length + 2 def unquote(:"#{helper}_path")(conn_or_endpoint, action, unquote_splicing(binding)) do path(conn_or_endpoint, "/") raise_route_error(unquote(helper), :path, unquote(arity), action, []) end def unquote(:"#{helper}_url")(conn_or_endpoint, action, unquote_splicing(binding)) do url(conn_or_endpoint) raise_route_error(unquote(helper), :url, unquote(arity), action, []) end end for length <- params_lengths do binding = List.duplicate({:_, [], nil}, length) arity = length + 2 def unquote(:"#{helper}_path")( conn_or_endpoint, action, unquote_splicing(binding), params ) do path(conn_or_endpoint, "/") raise_route_error(unquote(helper), :path, unquote(arity + 1), action, params) end def unquote(:"#{helper}_url")( conn_or_endpoint, action, unquote_splicing(binding), params ) do url(conn_or_endpoint) raise_route_error(unquote(helper), :url, unquote(arity + 1), action, params) end end defp raise_route_error(unquote(helper), suffix, arity, action, params) do Phoenix.Router.Helpers.raise_route_error( __MODULE__, "#{unquote(helper)}_#{suffix}", arity, action, unquote(Macro.escape(routes)), params ) end end end # It is in general bad practice to generate large chunks of code # inside quoted expressions. However, we can get away with this # here for two reasons: # # * Helper modules are quite uncommon, typically one per project. # # * We inline most of the code for performance, so it is specific # per helper module anyway. # code = quote do @moduledoc false unquote(defhelper) unquote(defcatch_all) unquote_splicing(impls) unquote_splicing(catch_all) @doc """ Generates the path information including any necessary prefix. """ def path(data, path) do Phoenix.VerifiedRoutes.unverified_path(data, unquote(env.module), path) end @doc """ Generates the connection/endpoint base URL without any path information. """ def url(data) do Phoenix.VerifiedRoutes.unverified_url(data, "") end @doc """ Generates path to a static asset given its file path. """ def static_path(conn_or_endpoint_ctx, path) do Phoenix.VerifiedRoutes.static_path(conn_or_endpoint_ctx, path) end @doc """ Generates url to a static asset given its file path. """ def static_url(conn_or_endpoint_ctx, path) do Phoenix.VerifiedRoutes.static_url(conn_or_endpoint_ctx, path) end @doc """ Generates an integrity hash to a static asset given its file path. """ def static_integrity(conn_or_endpoint_ctx, path) do Phoenix.VerifiedRoutes.static_integrity(conn_or_endpoint_ctx, path) end # Functions used by generated helpers # Those are inlined here for performance defp to_param(int) when is_integer(int), do: Integer.to_string(int) defp to_param(bin) when is_binary(bin), do: bin defp to_param(false), do: "false" defp to_param(true), do: "true" defp to_param(data), do: Phoenix.Param.to_param(data) defp segments(segments, [], _reserved, trailing_slash?, _opts) do maybe_append_slash(segments, trailing_slash?) end defp segments(segments, query, reserved, trailing_slash?, _opts) when is_list(query) or is_map(query) do dict = for {k, v} <- query, (k = to_string(k)) not in reserved, do: {k, v} case Conn.Query.encode(dict, &to_param/1) do "" -> maybe_append_slash(segments, trailing_slash?) o -> maybe_append_slash(segments, trailing_slash?) <> "?" <> o end end if unquote(trailing_slash?) do defp maybe_append_slash("/", _), do: "/" defp maybe_append_slash(path, true), do: path <> "/" end defp maybe_append_slash(path, _), do: path end name = Module.concat(env.module, Helpers) Module.create(name, code, line: env.line, file: env.file) name end @doc """ Receives a route and returns the quoted definition for its helper function. In case a helper name was not given, or route is forwarded, returns nil. """ def defhelper(%Route{} = route, exprs) do helper = route.helper opts = route.plug_opts trailing_slash? = route.trailing_slash? {bins, vars} = :lists.unzip(exprs.binding) segs = expand_segments(exprs.path) quote do defhelper.( unquote(helper), unquote(Macro.escape(vars)), unquote(Macro.escape(opts)), unquote(Macro.escape(bins)), unquote(Macro.escape(segs)), unquote(Macro.escape(trailing_slash?)) ) end end def defhelper_catch_all({helper, routes_and_exprs}) do routes = routes_and_exprs |> Enum.map(fn {routes, exprs} -> {routes.plug_opts, Enum.map(exprs.binding, &elem(&1, 0))} end) |> Enum.sort() params_lengths = routes |> Enum.map(fn {_, bindings} -> length(bindings) end) |> Enum.uniq() # Each helper defines catch all like this: # # def helper_path(context, action, ...binding) # def helper_path(context, action, ...binding, params) # # Given the helpers are ordered by binding length, the additional # helper with param for a helper_path/n will always override the # binding for helper_path/n+1, so we skip those here to avoid warnings. binding_lengths = Enum.reject(params_lengths, &((&1 - 1) in params_lengths)) quote do defcatch_all.( unquote(helper), unquote(binding_lengths), unquote(params_lengths), unquote(Macro.escape(routes)) ) end end @doc """ Callback for generate router catch all. """ def raise_route_error(mod, fun, arity, action, routes, params) do cond do is_atom(action) and not Keyword.has_key?(routes, action) -> "no action #{inspect(action)} for #{inspect(mod)}.#{fun}/#{arity}" |> invalid_route_error(fun, routes) is_list(params) or is_map(params) -> "no function clause for #{inspect(mod)}.#{fun}/#{arity} and action #{inspect(action)}" |> invalid_route_error(fun, routes) true -> invalid_param_error(mod, fun, arity, action, routes) end end defp invalid_route_error(prelude, fun, routes) do suggestions = for {action, bindings} <- routes do bindings = Enum.join([inspect(action) | bindings], ", ") "\n #{fun}(conn_or_endpoint, #{bindings}, params \\\\ [])" end raise ArgumentError, "#{prelude}. The following actions/clauses are supported:\n#{suggestions}" end defp invalid_param_error(mod, fun, arity, action, routes) do call_vars = Keyword.fetch!(routes, action) raise ArgumentError, """ #{inspect(mod)}.#{fun}/#{arity} called with invalid params. The last argument to this function should be a keyword list or a map. For example: #{fun}(#{Enum.join(["conn", ":#{action}" | call_vars], ", ")}, page: 5, per_page: 10) It is possible you have called this function without defining the proper number of path segments in your router. """ end @doc """ Callback for properly encoding parameters in routes. """ def encode_param(str), do: URI.encode(str, &URI.char_unreserved?/1) defp expand_segments([]), do: "/" defp expand_segments(segments) when is_list(segments) do expand_segments(segments, "") end defp expand_segments(segments) do quote(do: "/" <> Enum.map_join(unquote(segments), "/", &unquote(__MODULE__).encode_param/1)) end defp expand_segments([{:|, _, [h, t]}], acc), do: quote( do: unquote(expand_segments([h], acc)) <> "/" <> Enum.map_join(unquote(t), "/", &unquote(__MODULE__).encode_param/1) ) defp expand_segments([h | t], acc) when is_binary(h), do: expand_segments(t, quote(do: unquote(acc) <> unquote("/" <> h))) defp expand_segments([h | t], acc), do: expand_segments( t, quote(do: unquote(acc) <> "/" <> unquote(__MODULE__).encode_param(to_param(unquote(h)))) ) defp expand_segments([], acc), do: acc end ================================================ FILE: lib/phoenix/router/resource.ex ================================================ defmodule Phoenix.Router.Resource do # This module defines the Resource struct that is used # throughout Phoenix's router. This struct is private # as it contains internal routing information. @moduledoc false alias Phoenix.Router.Resource @default_param_key "id" @actions [:index, :edit, :new, :show, :create, :update, :delete] @doc """ The `Phoenix.Router.Resource` struct. It stores: * `:path` - the path as string (not normalized) * `:param` - the param to be used in routes (not normalized) * `:controller` - the controller as an atom * `:actions` - a list of actions as atoms * `:route` - the context for resource routes * `:member` - the context for member routes * `:collection` - the context for collection routes """ defstruct [:path, :actions, :param, :route, :controller, :member, :collection, :singleton] @type t :: %Resource{} @doc """ Builds a resource struct. """ def build(path, controller, options) when is_atom(controller) and is_list(options) do path = Phoenix.Router.Scope.validate_path(path) alias = Keyword.get(options, :alias) param = Keyword.get(options, :param, @default_param_key) name = Keyword.get(options, :name, Phoenix.Naming.resource_name(controller, "Controller")) as = Keyword.get(options, :as, name) private = Keyword.get(options, :private, %{}) assigns = Keyword.get(options, :assigns, %{}) singleton = Keyword.get(options, :singleton, false) actions = extract_actions(options, singleton) route = [as: as, private: private, assigns: assigns] collection = [path: path, as: as, private: private, assigns: assigns] member_path = if singleton, do: path, else: Path.join(path, ":#{name}_#{param}") member = [path: member_path, as: as, alias: alias, private: private, assigns: assigns] %Resource{path: path, actions: actions, param: param, route: route, member: member, collection: collection, controller: controller, singleton: singleton} end defp extract_actions(opts, singleton) do only = Keyword.get(opts, :only) except = Keyword.get(opts, :except) cond do only -> supported_actions = validate_actions(:only, singleton, only) supported_actions -- (supported_actions -- only) except -> supported_actions = validate_actions(:except, singleton, except) supported_actions -- except true -> default_actions(singleton) end end defp validate_actions(type, singleton, actions) do supported_actions = default_actions(singleton) unless actions -- supported_actions == [] do raise ArgumentError, """ invalid :#{type} action(s) passed to resources. supported#{if singleton, do: " singleton", else: ""} actions: #{inspect(supported_actions)} got: #{inspect(actions)} """ end supported_actions end defp default_actions(true = _singleton), do: @actions -- [:index] defp default_actions(false = _singleton), do: @actions end ================================================ FILE: lib/phoenix/router/route.ex ================================================ defmodule Phoenix.Router.Route do # This module defines the Route struct that is used # throughout Phoenix's router. This struct is private # as it contains internal routing information. @moduledoc false alias Phoenix.Router.Route @doc """ The `Phoenix.Router.Route` struct. It stores: * `:verb` - the HTTP verb as an atom * `:line` - the line the route was defined * `:kind` - the kind of route, either `:match` or `:forward` * `:path` - the normalized path as string * `:hosts` - the list of request hosts or host prefixes * `:plug` - the plug module * `:plug_opts` - the plug options * `:helper` - the name of the helper as a string (may be nil) * `:private` - the private route info * `:assigns` - the route info * `:pipe_through` - the pipeline names as a list of atoms * `:metadata` - general metadata used on telemetry events and route info * `:trailing_slash?` - whether or not the helper functions append a trailing slash * `:warn_on_verify?` - whether or not to warn on route verification """ defstruct [ :verb, :line, :kind, :path, :hosts, :plug, :plug_opts, :helper, :private, :pipe_through, :assigns, :metadata, :trailing_slash?, :warn_on_verify? ] @type t :: %Route{} @doc "Used as a plug on forwarding" def init(opts), do: opts @doc "Used as a plug on forwarding" def call(%{path_info: path, script_name: script} = conn, {fwd_segments, plug, opts}) do new_path = path -- fwd_segments {base, ^new_path} = Enum.split(path, length(path) - length(new_path)) conn = %{conn | path_info: new_path, script_name: script ++ base} conn = plug.call(conn, plug.init(opts)) %{conn | path_info: path, script_name: script} end @doc """ Receives the verb, path, plug, options and helper and returns a `Phoenix.Router.Route` struct. """ @spec build( non_neg_integer, :match | :forward, atom, String.t(), String.t() | nil, atom, atom, atom | nil, list(atom), map, map, map, boolean, boolean ) :: t def build( line, kind, verb, path, hosts, plug, plug_opts, helper, pipe_through, private, assigns, metadata, trailing_slash?, warn_on_verify? ) when is_atom(verb) and is_list(hosts) and is_atom(plug) and (is_binary(helper) or is_nil(helper)) and is_list(pipe_through) and is_map(private) and is_map(assigns) and is_map(metadata) and kind in [:match, :forward] and is_boolean(trailing_slash?) do %Route{ kind: kind, verb: verb, path: path, hosts: hosts, private: private, plug: plug, plug_opts: plug_opts, helper: helper, pipe_through: pipe_through, assigns: assigns, line: line, metadata: metadata, trailing_slash?: trailing_slash?, warn_on_verify?: warn_on_verify? } end @doc """ Builds the compiled expressions used by the route. """ def exprs(route) do {path, binding} = build_path_and_binding(route) %{ path: path, binding: binding, dispatch: build_dispatch(route), hosts: build_host_match(route.hosts), path_params: build_path_params(binding), prepare: build_prepare(route), verb_match: verb_match(route.verb) } end def build_host_match([]), do: [Plug.Router.Utils.build_host_match(nil)] def build_host_match([_ | _] = hosts) do for host <- hosts, do: Plug.Router.Utils.build_host_match(host) end defp verb_match(:*), do: Macro.var(:_verb, nil) defp verb_match(verb), do: verb |> to_string() |> String.upcase() defp build_path_params(binding), do: {:%{}, [], binding} defp build_path_and_binding(%Route{path: path} = route) do {_params, segments} = case route.kind do :forward -> Plug.Router.Utils.build_path_match(path <> "/*_forward_path_info") :match -> Plug.Router.Utils.build_path_match(path) end rewrite_segments(segments) end # We rewrite segments to use consistent variable naming as we want to group routes later on. defp rewrite_segments(segments) do {segments, {binding, _counter}} = Macro.prewalk(segments, {[], 0}, fn {name, _meta, nil}, {binding, counter} when is_atom(name) and name != :_forward_path_info -> var = Macro.var(:"arg#{counter}", __MODULE__) {var, {[{Atom.to_string(name), var} | binding], counter + 1}} other, acc -> {other, acc} end) {segments, Enum.reverse(binding)} end defp build_prepare(route) do {match_params, merge_params} = build_params() {match_private, merge_private} = build_prepare_expr(:private, route.private) {match_assigns, merge_assigns} = build_prepare_expr(:assigns, route.assigns) match_all = match_params ++ match_private ++ match_assigns merge_all = merge_params ++ merge_private ++ merge_assigns quote do %{unquote_splicing(match_all)} = var!(conn, :conn) %{var!(conn, :conn) | unquote_splicing(merge_all)} end end defp build_prepare_expr(_key, data) when data == %{}, do: {[], []} defp build_prepare_expr(key, data) do var = Macro.var(key, :conn) merge = quote(do: Map.merge(unquote(var), unquote(Macro.escape(data)))) {[{key, var}], [{key, merge}]} end defp build_dispatch(%Route{kind: :match, plug: plug, plug_opts: plug_opts}) do quote do {unquote(plug), unquote(Macro.escape(plug_opts))} end end defp build_dispatch(%Route{ kind: :forward, plug: plug, plug_opts: plug_opts, metadata: metadata }) do quote do { Phoenix.Router.Route, {unquote(metadata.forward), unquote(plug), unquote(Macro.escape(plug_opts))} } end end defp build_params() do params = Macro.var(:params, :conn) path_params = Macro.var(:path_params, :conn) merge_params = quote(do: Phoenix.Router.Route.merge_params(unquote(params), unquote(path_params))) { [{:params, params}], [{:params, merge_params}, {:path_params, path_params}] } end @doc """ Merges params from router. """ def merge_params(%Plug.Conn.Unfetched{}, path_params), do: path_params def merge_params(params, path_params), do: Map.merge(params, path_params) end ================================================ FILE: lib/phoenix/router/scope.ex ================================================ defmodule Phoenix.Router.Scope do alias Phoenix.Router.Scope @moduledoc false @stack :phoenix_router_scopes @pipes :phoenix_pipeline_scopes @top :phoenix_top_scopes defstruct path: [], alias: [], as: [], pipes: [], hosts: [], private: %{}, assigns: %{}, log: :debug, trailing_slash?: false @doc """ Initializes the scope. """ def init(module) do Module.put_attribute(module, @stack, []) Module.put_attribute(module, @top, %Scope{}) Module.put_attribute(module, @pipes, MapSet.new()) end @doc """ Builds a route based on the top of the stack. """ def route(line, module, kind, verb, path, plug, plug_opts, opts) do unless is_atom(plug) do raise ArgumentError, "routes expect a module plug as second argument, got: #{inspect(plug)}" end top = get_top(module) path = validate_path(path) private = Keyword.get(opts, :private, %{}) assigns = Keyword.get(opts, :assigns, %{}) as = Keyword.get_lazy(opts, :as, fn -> Phoenix.Naming.resource_name(plug, "Controller") end) alias? = Keyword.get(opts, :alias, true) trailing_slash? = deprecated_trailing_slash(opts, top) warn_on_verify? = Keyword.get(opts, :warn_on_verify, false) if to_string(as) == "static" do raise ArgumentError, "`static` is a reserved route prefix generated from #{inspect(plug)} or `:as` option" end {path, alias, as, private, assigns} = join(top, path, plug, alias?, as, private, assigns) metadata = opts |> Keyword.get(:metadata, %{}) |> Map.put(:log, Keyword.get(opts, :log, top.log)) metadata = if kind == :forward do Map.put(metadata, :forward, validate_forward!(path, plug)) else metadata end Phoenix.Router.Route.build( line, kind, verb, path, top.hosts, alias, plug_opts, as, top.pipes, private, assigns, metadata, trailing_slash?, warn_on_verify? ) end defp validate_forward!(path, plug) when is_atom(plug) do case Plug.Router.Utils.build_path_match(path) do {[], path_segments} -> path_segments _ -> raise ArgumentError, "dynamic segment \"#{path}\" not allowed when forwarding. Use a static path instead" end end defp validate_forward!(_, plug) do raise ArgumentError, "forward expects a module as the second argument, #{inspect(plug)} given" end @doc """ Validates a path is a string and contains a leading prefix. """ def validate_path("/" <> _ = path), do: path def validate_path(path) when is_binary(path) do IO.warn("router paths should begin with a forward slash, got: #{inspect(path)}") "/" <> path end def validate_path(path) do raise ArgumentError, "router paths must be strings, got: #{inspect(path)}" end @doc """ Defines the given pipeline. """ def pipeline(module, pipe) when is_atom(pipe) do update_pipes(module, &MapSet.put(&1, pipe)) end @doc """ Appends the given pipes to the current scope pipe through. """ def pipe_through(module, new_pipes) do new_pipes = List.wrap(new_pipes) %{pipes: pipes} = top = get_top(module) if pipe = Enum.find(new_pipes, &(&1 in pipes)) do raise ArgumentError, "duplicate pipe_through for #{inspect(pipe)}. " <> "A plug may only be used once inside a scoped pipe_through" end put_top(module, %{top | pipes: pipes ++ new_pipes}) end @doc """ Pushes a scope into the module stack. """ def push(module, path) when is_binary(path) do push(module, path: path) end def push(module, opts) when is_list(opts) do top = get_top(module) path = if path = Keyword.get(opts, :path) do path |> validate_path() |> String.split("/", trim: true) else [] end alias = append_unless_false(top, opts, :alias, &Atom.to_string(&1)) as = append_unless_false(top, opts, :as, & &1) hosts = case Keyword.fetch(opts, :host) do {:ok, val} -> validate_hosts!(val) :error -> top.hosts end private = Keyword.get(opts, :private, %{}) assigns = Keyword.get(opts, :assigns, %{}) update_stack(module, fn stack -> [top | stack] end) put_top(module, %Scope{ path: top.path ++ path, alias: alias, as: as, hosts: hosts, pipes: top.pipes, private: Map.merge(top.private, private), assigns: Map.merge(top.assigns, assigns), log: Keyword.get(opts, :log, top.log), trailing_slash?: deprecated_trailing_slash(opts, top) }) end defp deprecated_trailing_slash(opts, top) do case Keyword.fetch(opts, :trailing_slash) do {:ok, value} -> IO.warn( "the :trailing_slash option in the router is deprecated. " <> "If you are using Phoenix.VerifiedRoutes, it has no effect. " <> "If you are using the generated helpers, migrate to Phoenix.VerifiedRoutes" ) value == true :error -> top.trailing_slash? end end defp validate_hosts!(nil), do: [] defp validate_hosts!(host) when is_binary(host), do: [host] defp validate_hosts!(hosts) when is_list(hosts) do for host <- hosts do unless is_binary(host), do: raise_invalid_host(host) host end end defp validate_hosts!(invalid), do: raise_invalid_host(invalid) defp raise_invalid_host(host) do raise ArgumentError, "expected router scope :host to be compile-time string or list of strings, got: #{inspect(host)}" end defp append_unless_false(top, opts, key, fun) do case opts[key] do false -> [] nil -> Map.fetch!(top, key) other -> Map.fetch!(top, key) ++ [fun.(other)] end end @doc """ Pops a scope from the module stack. """ def pop(module) do update_stack(module, fn [top | stack] -> put_top(module, top) stack end) end @doc """ Expands the alias in the current router scope. """ def expand_alias(module, alias) do join_alias(get_top(module), alias) end @doc """ Returns the full path in the current router scope. """ def full_path(module, path) do split_path = String.split(path, "/", trim: true) prefix = get_top(module).path cond do prefix == [] -> path split_path == [] -> "/" <> Enum.join(prefix, "/") true -> "/" <> Path.join(get_top(module).path ++ split_path) end end defp join(top, path, alias, alias?, as, private, assigns) do joined_alias = if alias? do join_alias(top, alias) else alias end {join_path(top, path), joined_alias, join_as(top, as), Map.merge(top.private, private), Map.merge(top.assigns, assigns)} end defp join_path(top, path) do "/" <> Enum.join(top.path ++ String.split(path, "/", trim: true), "/") end defp join_alias(top, alias) when is_atom(alias) do case Atom.to_string(alias) do <> when head in ?a..?z -> alias alias -> Module.concat(top.alias ++ [alias]) end end defp join_as(_top, nil), do: nil defp join_as(top, as) when is_atom(as) or is_binary(as), do: Enum.join(top.as ++ [as], "_") defp get_top(module) do get_attribute(module, @top) end defp update_stack(module, fun) do update_attribute(module, @stack, fun) end defp update_pipes(module, fun) do update_attribute(module, @pipes, fun) end defp put_top(module, value) do Module.put_attribute(module, @top, value) value end defp get_attribute(module, attr) do Module.get_attribute(module, attr) || raise "Phoenix router scope was not initialized" end defp update_attribute(module, attr, fun) do Module.put_attribute(module, attr, fun.(get_attribute(module, attr))) end end ================================================ FILE: lib/phoenix/router.ex ================================================ defmodule Phoenix.Router do defmodule NoRouteError do @moduledoc """ Exception raised when no route is found. """ defexception plug_status: 404, message: "no route found", conn: nil, router: nil def exception(opts) do conn = Keyword.fetch!(opts, :conn) router = Keyword.fetch!(opts, :router) path = "/" <> Enum.join(conn.path_info, "/") %NoRouteError{ message: "no route found for #{conn.method} #{path} (#{inspect(router)})", conn: conn, router: router } end end defmodule MalformedURIError do @moduledoc """ Exception raised when the URI is malformed on matching. """ defexception [:message, plug_status: 400] end @moduledoc """ Defines a Phoenix router. The router provides a set of macros for generating routes that dispatch to specific controllers and actions. Those macros are named after HTTP verbs. For example: defmodule MyAppWeb.Router do use Phoenix.Router get "/pages/:page", PageController, :show end The `get/3` macro above accepts a request to `/pages/hello` and dispatches it to `PageController`'s `show` action with `%{"page" => "hello"}` in `params`. Phoenix's router is extremely efficient, as it relies on Elixir pattern matching for matching routes and serving requests. ## Routing `get/3`, `post/3`, `put/3`, and other macros named after HTTP verbs are used to create routes. The route: get "/pages", PageController, :index matches a `GET` request to `/pages` and dispatches it to the `index` action in `PageController`. get "/pages/:page", PageController, :show matches `/pages/hello` and dispatches to the `show` action with `%{"page" => "hello"}` in `params`. defmodule PageController do def show(conn, params) do # %{"page" => "hello"} == params end end Partial and multiple segments can be matched. For example: get "/api/v:version/pages/:id", PageController, :show matches `/api/v1/pages/2` and puts `%{"version" => "1", "id" => "2"}` in `params`. Only the trailing part of a segment can be captured. Routes are matched from top to bottom. The second route here: get "/pages/:page", PageController, :show get "/pages/hello", PageController, :hello will never match `/pages/hello` because `/pages/:page` matches that first. Routes can use glob-like patterns to match trailing segments. get "/pages/*page", PageController, :show matches `/pages/hello/world` and puts the globbed segments in `params["page"]`. GET /pages/hello/world %{"page" => ["hello", "world"]} = params Globs cannot have prefixes nor suffixes, but can be mixed with variables: get "/pages/he:page/*rest", PageController, :show matches GET /pages/hello %{"page" => "llo", "rest" => []} = params GET /pages/hey/there/world %{"page" => "y", "rest" => ["there" "world"]} = params > #### Why the macros? {: .info} > > Phoenix does its best to keep the usage of macros low. You may have noticed, > however, that the `Phoenix.Router` relies heavily on macros. Why is that? > > We use `get`, `post`, `put`, and `delete` to define your routes. We use macros > for two purposes: > > * They define the routing engine, used on every request, to choose which > controller to dispatch the request to. Thanks to macros, Phoenix compiles > all of your routes to a single case-statement with pattern matching rules, > which is heavily optimized by the Erlang VM > > * For each route you define, we also define metadata to implement `Phoenix.VerifiedRoutes`. > As we will soon learn, verified routes allows to us to reference any route > as if it is a plain looking string, except it is verified by the compiler > to be valid (making it much harder to ship broken links, forms, mails, etc > to production) > > In other words, the router relies on macros to build applications that are > faster and safer. Also remember that macros in Elixir are compile-time only, > which gives plenty of stability after the code is compiled. Phoenix also provides > introspection for all defined routes via `mix phx.routes`. ## Generating routes For generating routes inside your application, see the `Phoenix.VerifiedRoutes` documentation for `~p` based route generation which is the preferred way to generate route paths and URLs with compile-time verification. Phoenix also supports generating function helpers, which was the default mechanism in Phoenix v1.6 and earlier. We will explore it next. ### Helpers (deprecated) Phoenix generates a module `Helpers` inside your router by default, which contains named helpers to help developers generate and keep their routes up to date. Helpers can be disabled by passing `helpers: false` to `use Phoenix.Router`. Helpers are automatically generated based on the controller name. For example, the route: get "/pages/:page", PageController, :show will generate the following named helper: MyAppWeb.Router.Helpers.page_path(conn_or_endpoint, :show, "hello") "/pages/hello" MyAppWeb.Router.Helpers.page_path(conn_or_endpoint, :show, "hello", some: "query") "/pages/hello?some=query" MyAppWeb.Router.Helpers.page_url(conn_or_endpoint, :show, "hello") "http://example.com/pages/hello" MyAppWeb.Router.Helpers.page_url(conn_or_endpoint, :show, "hello", some: "query") "http://example.com/pages/hello?some=query" If the route contains glob-like patterns, parameters for those have to be given as list: MyAppWeb.Router.Helpers.page_path(conn_or_endpoint, :show, ["hello", "world"]) "/pages/hello/world" The URL generated in the named URL helpers is based on the configuration for `:url`, `:http` and `:https`. However, if for some reason you need to manually control the URL generation, the url helpers also allow you to pass in a `URI` struct: uri = %URI{scheme: "https", host: "other.example.com"} MyAppWeb.Router.Helpers.page_url(uri, :show, "hello") "https://other.example.com/pages/hello" The named helper can also be customized with the `:as` option. Given the route: get "/pages/:page", PageController, :show, as: :special_page the named helper will be: MyAppWeb.Router.Helpers.special_page_path(conn, :show, "hello") "/pages/hello" ## Scopes and Resources It is very common in Phoenix applications to namespace all of your routes under the application scope: scope "/", MyAppWeb do get "/pages/:id", PageController, :show end The route above will dispatch to `MyAppWeb.PageController`. This syntax is convenient for developers, since we don't have to repeat `MyAppWeb.` prefix on all routes Like all paths, you can define dynamic segments that will be applied as parameters in the controller: scope "/api/:version", MyAppWeb do get "/pages/:id", PageController, :show end For example, the route above will match on the path `"/api/v1/pages/1"` and in the controller the `params` argument will have a map with the key `:version` with the value `"v1"`. Phoenix also provides a `resources/4` macro that allows developers to generate "RESTful" routes to a given resource: defmodule MyAppWeb.Router do use Phoenix.Router, helpers: false resources "/pages", PageController, only: [:show] resources "/users", UserController, except: [:delete] end Finally, Phoenix ships with a `mix phx.routes` task that nicely formats all routes in a given router. We can use it to verify all routes included in the router above: $ mix phx.routes GET /pages/:id PageController.show/2 GET /users UserController.index/2 GET /users/:id/edit UserController.edit/2 GET /users/new UserController.new/2 GET /users/:id UserController.show/2 POST /users UserController.create/2 PATCH /users/:id UserController.update/2 PUT /users/:id UserController.update/2 One can also pass a router explicitly as an argument to the task: $ mix phx.routes MyAppWeb.Router Check `scope/2` and `resources/4` for more information. ## Pipelines and plugs Once a request arrives at the Phoenix router, it performs a series of transformations through pipelines until the request is dispatched to a desired route. Such transformations are defined via plugs, as defined in the [Plug](https://github.com/elixir-lang/plug) specification. Once a pipeline is defined, it can be piped through per scope. For example: defmodule MyAppWeb.Router do use Phoenix.Router pipeline :browser do plug :fetch_session plug :accepts, ["html"] end scope "/" do pipe_through :browser # browser related routes and resources end end `Phoenix.Router` imports functions from both `Plug.Conn` and `Phoenix.Controller` to help define plugs. In the example above, `fetch_session/2` comes from `Plug.Conn` while `accepts/2` comes from `Phoenix.Controller`. Note that router pipelines are only invoked after a route is found. No plug is invoked in case no matches were found. ## Learn more See the [Routing](routing.md) guide for more information and examples within an actual Phoenix application. """ alias Phoenix.Router.{Resource, Scope, Route, Helpers} @http_methods [:get, :post, :put, :patch, :delete, :options, :connect, :trace, :head] @doc false defmacro __using__(opts) do quote do unquote(prelude(opts)) unquote(defs()) unquote(match_dispatch()) unquote(verified_routes()) end end defp prelude(opts) do quote do Module.register_attribute(__MODULE__, :phoenix_routes, accumulate: true) # TODO: Require :helpers to be explicit given @phoenix_helpers Keyword.get(unquote(opts), :helpers, true) import Phoenix.Router # TODO v2: No longer automatically import dependencies import Plug.Conn import Phoenix.Controller # Set up initial scope @phoenix_pipeline nil Phoenix.Router.Scope.init(__MODULE__) @before_compile unquote(__MODULE__) end end # Because those macros are executed multiple times, # we end-up generating a huge scope that drastically # affects compilation. We work around it by defining # those functions only once and calling it over and # over again. defp defs() do quote unquote: false do var!(add_resources, Phoenix.Router) = fn resource -> path = resource.path ctrl = resource.controller opts = resource.route if resource.singleton do Enum.each(resource.actions, fn :show -> get path, ctrl, :show, opts :new -> get path <> "/new", ctrl, :new, opts :edit -> get path <> "/edit", ctrl, :edit, opts :create -> post path, ctrl, :create, opts :delete -> delete path, ctrl, :delete, opts :update -> patch path, ctrl, :update, opts put path, ctrl, :update, Keyword.put(opts, :as, nil) end) else param = resource.param Enum.each(resource.actions, fn :index -> get path, ctrl, :index, opts :show -> get path <> "/:" <> param, ctrl, :show, opts :new -> get path <> "/new", ctrl, :new, opts :edit -> get path <> "/:" <> param <> "/edit", ctrl, :edit, opts :create -> post path, ctrl, :create, opts :delete -> delete path <> "/:" <> param, ctrl, :delete, opts :update -> patch path <> "/:" <> param, ctrl, :update, opts put path <> "/:" <> param, ctrl, :update, Keyword.put(opts, :as, nil) end) end end end end @doc false def __call__( %{private: %{phoenix_router: router, phoenix_bypass: {router, pipes}}} = conn, metadata, prepare, pipeline, _ ) do conn = prepare.(conn, metadata) case pipes do :current -> pipeline.(conn) _ -> Enum.reduce(pipes, conn, fn pipe, acc -> apply(router, pipe, [acc, []]) end) end end def __call__(%{private: %{phoenix_bypass: :all}} = conn, metadata, prepare, _, _) do prepare.(conn, metadata) end def __call__(conn, metadata, prepare, pipeline, {plug, opts}) do conn = prepare.(conn, metadata) start = System.monotonic_time() measurements = %{system_time: System.system_time()} metadata = %{metadata | conn: conn} :telemetry.execute([:phoenix, :router_dispatch, :start], measurements, metadata) case pipeline.(conn) do %Plug.Conn{halted: true} = halted_conn -> measurements = %{duration: System.monotonic_time() - start} metadata = %{metadata | conn: halted_conn} :telemetry.execute([:phoenix, :router_dispatch, :stop], measurements, metadata) halted_conn %Plug.Conn{} = piped_conn -> try do plug.call(piped_conn, plug.init(opts)) else conn -> measurements = %{duration: System.monotonic_time() - start} metadata = %{metadata | conn: conn} :telemetry.execute([:phoenix, :router_dispatch, :stop], measurements, metadata) conn rescue e in Plug.Conn.WrapperError -> measurements = %{duration: System.monotonic_time() - start} new_metadata = %{conn: conn, kind: :error, reason: e, stacktrace: __STACKTRACE__} metadata = Map.merge(metadata, new_metadata) :telemetry.execute([:phoenix, :router_dispatch, :exception], measurements, metadata) Plug.Conn.WrapperError.reraise(e) catch kind, reason -> measurements = %{duration: System.monotonic_time() - start} new_metadata = %{conn: conn, kind: kind, reason: reason, stacktrace: __STACKTRACE__} metadata = Map.merge(metadata, new_metadata) :telemetry.execute([:phoenix, :router_dispatch, :exception], measurements, metadata) Plug.Conn.WrapperError.reraise(piped_conn, kind, reason, __STACKTRACE__) end end end defp match_dispatch() do quote location: :keep, generated: true do @behaviour Plug @doc """ Callback required by Plug that initializes the router for serving web requests. """ def init(opts) do opts end @doc """ Callback invoked by Plug on every request. """ def call(conn, _opts) do %{method: method, path_info: path_info, host: host} = conn = prepare(conn) decoded = Enum.map(path_info, &URI.decode/1) case __match_route__(decoded, method, host) do {metadata, prepare, pipeline, plug_opts} -> Phoenix.Router.__call__(conn, metadata, prepare, pipeline, plug_opts) :error -> raise NoRouteError, conn: conn, router: __MODULE__ end end defoverridable init: 1, call: 2 end end defp verified_routes() do quote location: :keep, generated: true do @behaviour Phoenix.VerifiedRoutes def formatted_routes(_) do Phoenix.Router.__formatted_routes__(__MODULE__) end def verified_route?(_, split_path) do Phoenix.Router.__verified_route__?(__MODULE__, split_path) end end end @doc false defmacro __before_compile__(env) do routes = env.module |> Module.get_attribute(:phoenix_routes) |> Enum.reverse() routes_with_exprs = Enum.map(routes, &{&1, Route.exprs(&1)}) helpers = if Module.get_attribute(env.module, :phoenix_helpers) do Helpers.define(env, routes_with_exprs) end {matches, {pipelines, _}} = Enum.map_reduce(routes_with_exprs, {[], %{}}, &build_match/2) routes_per_path = routes_with_exprs |> Enum.group_by(&elem(&1, 1).path, &elem(&1, 0)) verifies = routes_with_exprs |> Enum.map(&elem(&1, 1).path) |> Enum.uniq() |> Enum.map(&build_verify(&1, routes_per_path)) verify_catch_all = quote generated: true do @doc false def __verify_route__(_path_info) do :error end end match_catch_all = quote generated: true do @doc false def __match_route__(_path_info, _verb, _host) do :error end end forward_catch_all = quote generated: true do @doc false def __forward__(_), do: nil end checks = routes |> Enum.map(fn %{line: line, metadata: metadata, plug: plug} -> {line, Map.get(metadata, :mfa, {plug, :init, 1})} end) |> Enum.uniq() |> Enum.map(fn {line, {module, function, arity}} -> quote line: line, do: _ = &(unquote(module).unquote(function) / unquote(arity)) end) keys = [:verb, :path, :plug, :plug_opts, :helper, :metadata] routes = Enum.map(routes, &Map.take(&1, keys)) quote do @doc false def __routes__, do: unquote(Macro.escape(routes)) @doc false def __checks__, do: unquote({:__block__, [], checks}) @doc false def __helpers__, do: unquote(helpers) defp prepare(conn) do merge_private(conn, [{:phoenix_router, __MODULE__}, {__MODULE__, conn.script_name}]) end unquote(pipelines) unquote(verifies) unquote(verify_catch_all) unquote(matches) unquote(match_catch_all) unquote(forward_catch_all) end end defp build_verify(path, routes_per_path) do routes = Map.get(routes_per_path, path) warn_on_verify? = Enum.all?(routes, & &1.warn_on_verify?) case Enum.find(routes, &(&1.kind == :forward)) do %{metadata: %{forward: forward}, plug: plug, plug_opts: plug_opts} -> quote generated: true do def __forward__(unquote(plug)) do unquote(forward) end def __verify_route__(unquote(path)) do {{unquote(plug), unquote(forward), unquote(Macro.escape(plug_opts))}, unquote(warn_on_verify?)} end end _ -> quote generated: true do def __verify_route__(unquote(path)) do {nil, unquote(warn_on_verify?)} end end end end defp build_match({route, expr}, {acc_pipes, known_pipes}) do {pipe_name, acc_pipes, known_pipes} = build_match_pipes(route, acc_pipes, known_pipes) %{ prepare: prepare, dispatch: dispatch, verb_match: verb_match, path_params: path_params, hosts: hosts, path: path } = expr clauses = for host <- hosts do quote line: route.line do def __match_route__(unquote(path), unquote(verb_match), unquote(host)) do {unquote(build_metadata(route, path_params)), fn var!(conn, :conn), %{path_params: var!(path_params, :conn)} -> unquote(prepare) end, &(unquote(Macro.var(pipe_name, __MODULE__)) / 1), unquote(dispatch)} end end end {clauses, {acc_pipes, known_pipes}} end defp build_match_pipes(route, acc_pipes, known_pipes) do %{pipe_through: pipe_through} = route case known_pipes do %{^pipe_through => name} -> {name, acc_pipes, known_pipes} %{} -> name = :"__pipe_through#{map_size(known_pipes)}__" acc_pipes = [build_pipes(name, pipe_through) | acc_pipes] known_pipes = Map.put(known_pipes, pipe_through, name) {name, acc_pipes, known_pipes} end end defp build_metadata(route, path_params) do %{ path: path, plug: plug, plug_opts: plug_opts, pipe_through: pipe_through, metadata: metadata } = route pairs = [ conn: nil, route: path, plug: plug, plug_opts: Macro.escape(plug_opts), path_params: path_params, pipe_through: pipe_through ] {:%{}, [], pairs ++ Macro.escape(Map.to_list(metadata))} end defp build_pipes(name, []) do quote do defp unquote(name)(conn), do: conn end end defp build_pipes(name, pipe_through) do plugs = pipe_through |> Enum.reverse() |> Enum.map(&{&1, [], true}) opts = [init_mode: Phoenix.plug_init_mode(), log_on_halt: :debug] {conn, body} = Plug.Builder.compile(__ENV__, plugs, opts) quote do defp unquote(name)(unquote(conn)), do: unquote(body) end end @doc """ Generates a route match based on an arbitrary HTTP method. Useful for defining routes not included in the built-in macros. The catch-all verb, `:*`, may also be used to match all HTTP methods. ## Options * `:as` - configures the named helper. If `nil`, does not generate a helper. Has no effect when using verified routes exclusively * `:alias` - configure if the scope alias should be applied to the route. Defaults to true, disables scoping if false. * `:log` - the level to log the route dispatching under, may be set to false. Defaults to `:debug`. Route dispatching contains information about how the route is handled (which controller action is called, what parameters are available and which pipelines are used) and is separate from the plug level logging. To alter the plug log level, please see https://hexdocs.pm/phoenix/Phoenix.Logger.html#module-dynamic-log-level. * `:private` - a map of private data to merge into the connection when a route matches * `:assigns` - a map of data to merge into the connection when a route matches * `:metadata` - a map of metadata used by the telemetry events and returned by `route_info/4`. The `:mfa` field is used by telemetry to print logs and by the router to emit compile time checks. Custom fields may be added. * `:warn_on_verify` - the boolean for whether matches to this route trigger an unmatched route warning for `Phoenix.VerifiedRoutes`. It is useful to ignore an otherwise catch-all route definition from being matched when verifying routes. Defaults `false`. ## Examples match(:move, "/events/:id", EventController, :move) match(:*, "/any", SomeController, :any) """ defmacro match(verb, path, plug, plug_opts, options \\ []) do add_route(:match, verb, path, expand_alias(plug, __CALLER__), plug_opts, options) end for verb <- @http_methods do @doc """ Generates a route to handle a #{verb} request to the given path. #{verb}("/events/:id", EventController, :action) See `match/5` for options. #{if verb == :head do """ ## Compatibility with `Plug.Head` By default, Phoenix applications include `Plug.Head` in their endpoint, which converts HEAD requests into regular GET requests. Therefore, if you intend to use `head/4` in your router, you need to move `Plug.Head` to inside your router in a way it does not conflict with the paths given to `head/4`. """ end} """ defmacro unquote(verb)(path, plug, plug_opts, options \\ []) do add_route(:match, unquote(verb), path, expand_alias(plug, __CALLER__), plug_opts, options) end end defp add_route(kind, verb, path, plug, plug_opts, options) do quote do @phoenix_routes Scope.route( __ENV__.line, __ENV__.module, unquote(kind), unquote(verb), unquote(path), unquote(plug), unquote(plug_opts), unquote(options) ) end end @doc """ Defines a plug pipeline. Pipelines are defined at the router root and can be used from any scope. ## Examples pipeline :api do plug :token_authentication plug :dispatch end A scope may then use this pipeline as: scope "/" do pipe_through :api end Every time `pipe_through/1` is called, the new pipelines are appended to the ones previously given. """ defmacro pipeline(plug, do: block) do with true <- is_atom(plug), imports = __CALLER__.macros ++ __CALLER__.functions, {mod, _} <- Enum.find(imports, fn {_, imports} -> {plug, 2} in imports end) do raise ArgumentError, "cannot define pipeline named #{inspect(plug)} " <> "because there is an import from #{inspect(mod)} with the same name" end block = quote do plug = unquote(plug) @phoenix_pipeline [] unquote(block) end compiler = quote unquote: false do Scope.pipeline(__MODULE__, plug) {conn, body} = Plug.Builder.compile(__ENV__, @phoenix_pipeline, init_mode: Phoenix.plug_init_mode()) def unquote(plug)(unquote(conn), _) do try do unquote(body) rescue e in Plug.Conn.WrapperError -> Plug.Conn.WrapperError.reraise(e) catch :error, reason -> Plug.Conn.WrapperError.reraise(unquote(conn), :error, reason, __STACKTRACE__) end end @phoenix_pipeline nil end quote do try do unquote(block) unquote(compiler) after :ok end end end @doc """ Defines a plug inside a pipeline. See `pipeline/2` for more information. """ defmacro plug(plug, opts \\ []) do {plug, opts} = expand_plug_and_opts(plug, opts, __CALLER__) quote do if pipeline = @phoenix_pipeline do @phoenix_pipeline [{unquote(plug), unquote(opts), true} | pipeline] else raise "cannot define plug at the router level, plug must be defined inside a pipeline" end end end defp expand_plug_and_opts(plug, opts, caller) do runtime? = Phoenix.plug_init_mode() == :runtime plug = if runtime? do expand_alias(plug, caller) else plug end opts = if runtime? and Macro.quoted_literal?(opts) do Macro.prewalk(opts, &expand_alias(&1, caller)) else opts end {plug, opts} end defp expand_alias({:__aliases__, _, _} = alias, env), do: Macro.expand(alias, %{env | function: {:init, 1}}) defp expand_alias(other, _env), do: other @doc """ Defines a list of plugs (and pipelines) to send the connection through. Plugs are specified using the atom name of any imported 2-arity function which takes a `Plug.Conn` and options and returns a `Plug.Conn`. For example, `:require_authenticated_user`. Pipelines are defined in the router, see `pipeline/2` for more information. pipe_through [:require_authenticated_user, :my_browser_pipeline] ## Multiple invocations `pipe_through/1` can be invoked multiple times within the same scope. Each invocation appends new plugs and pipelines to run, which are applied to all routes **after** the `pipe_through/1` invocation. For example: scope "/" do pipe_through [:browser] get "/", HomeController, :index pipe_through [:require_authenticated_user] get "/settings", UserController, :edit end In the example above, `/` pipes through `browser` only, while `/settings` pipes through both `browser` and `require_authenticated_user`. Therefore, to avoid confusion, we recommend a single `pipe_through` at the top of each scope: scope "/" do pipe_through [:browser] get "/", HomeController, :index end scope "/" do pipe_through [:browser, :require_authenticated_user] get "/settings", UserController, :edit end """ defmacro pipe_through(pipes) do pipes = if Phoenix.plug_init_mode() == :runtime and Macro.quoted_literal?(pipes) do Macro.prewalk(pipes, &expand_alias(&1, __CALLER__)) else pipes end quote do if pipeline = @phoenix_pipeline do raise "cannot pipe_through inside a pipeline" else Scope.pipe_through(__MODULE__, unquote(pipes)) end end end @doc """ Defines "RESTful" routes for a resource. The given definition: resources "/users", UserController will include routes to the following actions: * `GET /users` => `:index` * `GET /users/new` => `:new` * `POST /users` => `:create` * `GET /users/:id` => `:show` * `GET /users/:id/edit` => `:edit` * `PATCH /users/:id` => `:update` * `PUT /users/:id` => `:update` * `DELETE /users/:id` => `:delete` ## Options This macro accepts a set of options: * `:only` - a list of actions to generate routes for, for example: `[:show, :edit]` * `:except` - a list of actions to exclude generated routes from, for example: `[:delete]` * `:param` - the name of the parameter for this resource, defaults to `"id"` * `:name` - the prefix for this resource. This is used for the named helper and as the prefix for the parameter in nested resources. The default value is automatically derived from the controller name, i.e. `UserController` will have name `"user"` * `:as` - configures the named helper. If `nil`, does not generate a helper. Has no effect when using verified routes exclusively * `:singleton` - defines routes for a singleton resource that is looked up by the client without referencing an ID. Read below for more information ## Singleton resources When a resource needs to be looked up without referencing an ID, because it contains only a single entry in the given context, the `:singleton` option can be used to generate a set of routes that are specific to such single resource: * `GET /user` => `:show` * `GET /user/new` => `:new` * `POST /user` => `:create` * `GET /user/edit` => `:edit` * `PATCH /user` => `:update` * `PUT /user` => `:update` * `DELETE /user` => `:delete` Usage example: resources "/account", AccountController, only: [:show], singleton: true ## Nested Resources This macro also supports passing a nested block of route definitions. This is helpful for nesting children resources within their parents to generate nested routes. The given definition: resources "/users", UserController do resources "/posts", PostController end will include the following routes: ```console user_post_path GET /users/:user_id/posts PostController :index user_post_path GET /users/:user_id/posts/:id/edit PostController :edit user_post_path GET /users/:user_id/posts/new PostController :new user_post_path GET /users/:user_id/posts/:id PostController :show user_post_path POST /users/:user_id/posts PostController :create user_post_path PATCH /users/:user_id/posts/:id PostController :update PUT /users/:user_id/posts/:id PostController :update user_post_path DELETE /users/:user_id/posts/:id PostController :delete ``` """ defmacro resources(path, controller, opts, do: nested_context) do add_resources(path, controller, opts, do: nested_context) end @doc """ See `resources/4`. """ defmacro resources(path, controller, do: nested_context) do add_resources(path, controller, [], do: nested_context) end defmacro resources(path, controller, opts) do add_resources(path, controller, opts, do: nil) end @doc """ See `resources/4`. """ defmacro resources(path, controller) do add_resources(path, controller, [], do: nil) end defp add_resources(path, controller, options, do: context) do scope = if context do quote do scope(resource.member, do: unquote(context)) end end quote do resource = Resource.build(unquote(path), unquote(controller), unquote(options)) var!(add_resources, Phoenix.Router).(resource) unquote(scope) end end @doc """ Defines a scope in which routes can be nested. ## Examples scope path: "/api/v1", alias: API.V1 do get "/pages/:id", PageController, :show end The generated route above will match on the path `"/api/v1/pages/:id"` and will dispatch to `:show` action in `API.V1.PageController`. A named helper `api_v1_page_path` will also be generated. ## Options The supported options are: * `:path` - a string containing the path scope. * `:as` - a string or atom containing the named helper scope. When set to false, it resets the nested helper scopes. Has no effect when using verified routes exclusively * `:alias` - an alias (atom) containing the controller scope. When set to false, it resets all nested aliases. * `:host` - a string or list of strings containing the host scope, or prefix host scope, ie `"foo.bar.com"`, `"foo."` * `:private` - a map of private data to merge into the connection when a route matches * `:assigns` - a map of data to merge into the connection when a route matches * `:log` - the level to log the route dispatching under, may be set to false. Defaults to `:debug`. Route dispatching contains information about how the route is handled (which controller action is called, what parameters are available and which pipelines are used) and is separate from the plug level logging. To alter the plug log level, please see https://hexdocs.pm/phoenix/Phoenix.Logger.html#module-dynamic-log-level. """ defmacro scope(options, do: context) do options = if Macro.quoted_literal?(options) do Macro.prewalk(options, &expand_alias(&1, __CALLER__)) else options end do_scope(options, context) end @doc """ Define a scope with the given path. This function is a shortcut for: scope path: path do ... end ## Examples scope "/v1", host: "api." do get "/pages/:id", PageController, :show end """ defmacro scope(path, options, do: context) do options = if Macro.quoted_literal?(options) do Macro.prewalk(options, &expand_alias(&1, __CALLER__)) else options end options = quote do path = unquote(path) case unquote(options) do alias when is_atom(alias) -> [path: path, alias: alias] options when is_list(options) -> Keyword.put(options, :path, path) end end do_scope(options, context) end @doc """ Defines a scope with the given path and alias. This function is a shortcut for: scope path: path, alias: alias do ... end ## Examples scope "/v1", API.V1, host: "api." do get "/pages/:id", PageController, :show end """ defmacro scope(path, alias, options, do: context) do alias = expand_alias(alias, __CALLER__) options = quote do unquote(options) |> Keyword.put(:path, unquote(path)) |> Keyword.put(:alias, unquote(alias)) end do_scope(options, context) end defp do_scope(options, context) do quote do Scope.push(__MODULE__, unquote(options)) try do unquote(context) after Scope.pop(__MODULE__) end end end @doc """ Returns the full alias with the current scope's aliased prefix. Useful for applying the same short-hand alias handling to other values besides the second argument in route definitions. ## Examples scope "/", MyPrefix do get "/", ProxyPlug, controller: scoped_alias(__MODULE__, MyController) end """ @doc type: :reflection def scoped_alias(router_module, alias) do Scope.expand_alias(router_module, alias) end @doc """ Returns the full path with the current scope's path prefix. """ @doc type: :reflection def scoped_path(router_module, path) do Scope.full_path(router_module, path) end @doc """ Forwards a request at the given path to a plug. This is commonly used to forward all subroutes to another Plug. For example: forward "/admin", SomeLib.AdminDashboard The above will allow `SomeLib.AdminDashboard` to handle `/admin`, `/admin/foo`, `/admin/bar/baz`, and so on. Furthermore, `SomeLib.AdminDashboard` does not to be aware of the prefix it is mounted in. From its point of view, the routes above are simply handled as `/`, `/foo`, and `/bar/baz`. A common use case for `forward` is for sharing a router between applications or even breaking a big router into smaller ones. However, in other for route generation to route accordingly, you can only forward to a given `Phoenix.Router` once. The router pipelines will be invoked prior to forwarding the connection. ## Examples scope "/", MyApp do pipe_through [:browser, :admin] forward "/admin", SomeLib.AdminDashboard forward "/api", ApiRouter end """ defmacro forward(path, plug, plug_opts \\ [], router_opts \\ []) do {plug, plug_opts} = expand_plug_and_opts(plug, plug_opts, __CALLER__) router_opts = Keyword.put(router_opts, :as, nil) quote unquote: true, bind_quoted: [path: path, plug: plug] do unquote(add_route(:forward, :*, path, plug, plug_opts, router_opts)) end end @doc """ Returns all routes information from the given router. """ def routes(router) do router.__routes__() end @doc """ Returns the compile-time route info and runtime path params for a request. The `path` can be either a string or the `path_info` segments. A map of metadata is returned with the following keys: * `:log` - the configured log level. For example `:debug` * `:path_params` - the map of runtime path params * `:pipe_through` - the list of pipelines for the route's scope, for example `[:browser]` * `:plug` - the plug to dispatch the route to, for example `AppWeb.PostController` * `:plug_opts` - the options to pass when calling the plug, for example: `:index` * `:route` - the string route pattern, such as `"/posts/:id"` ## Examples iex> Phoenix.Router.route_info(AppWeb.Router, "GET", "/posts/123", "myhost") %{ log: :debug, path_params: %{"id" => "123"}, pipe_through: [:browser], plug: AppWeb.PostController, plug_opts: :show, route: "/posts/:id", } iex> Phoenix.Router.route_info(MyRouter, "GET", "/not-exists", "myhost") :error """ @doc type: :reflection def route_info(router, method, path, host) when is_binary(path) do split_path = for segment <- String.split(path, "/"), segment != "", do: segment route_info(router, method, split_path, host) end def route_info(router, method, split_path, host) when is_list(split_path) do with {metadata, _prepare, _pipeline, {_plug, _opts}} <- router.__match_route__(split_path, method, host) do Map.delete(metadata, :conn) end end @doc false def __formatted_routes__(router) do Enum.flat_map(router.__routes__(), fn route -> Code.ensure_loaded(route.plug) if function_exported?(route.plug, :formatted_routes, 1) do route.plug_opts |> route.plug.formatted_routes() |> Enum.map(fn nested_route -> route = %{ route | path: Path.join(route.path, nested_route.path), verb: nested_route.verb } Map.put(route, :label, nested_route.label) end) else plug = case route.metadata[:mfa] do {module, _, _} -> module _ -> route.plug end label = "#{inspect(plug)} #{inspect(route.plug_opts)}" [ %{ helper: route.helper, verb: route.verb, path: route.path, label: label } ] end end) end @doc false def __verified_route__?(router, split_path) do case router.__verify_route__(split_path) do {_forward_plug, true = _warn_on_verify?} -> false {nil = _forward_plug, false = _warn_on_verify?} -> true {{router, script_name, plug_opts}, false = _warn_on_verify?} -> Code.ensure_loaded(router) if function_exported?(router, :verified_route?, 2) do router.verified_route?(plug_opts, split_path -- script_name) else true end :error -> false end end end ================================================ FILE: lib/phoenix/socket/message.ex ================================================ defmodule Phoenix.Socket.Message do @moduledoc """ Defines a message dispatched over transport to channels and vice-versa. The message format requires the following keys: * `:topic` - The string topic or topic:subtopic pair namespace, for example "messages", "messages:123" * `:event`- The string event name, for example "phx_join" * `:payload` - The message payload * `:ref` - The unique string ref * `:join_ref` - The unique string ref when joining """ @type t :: %Phoenix.Socket.Message{} defstruct topic: nil, event: nil, payload: nil, ref: nil, join_ref: nil @doc """ Converts a map with string keys into a message struct. Raises `Phoenix.Socket.InvalidMessageError` if not valid. """ def from_map!(map) when is_map(map) do try do %Phoenix.Socket.Message{ topic: Map.fetch!(map, "topic"), event: Map.fetch!(map, "event"), payload: Map.fetch!(map, "payload"), ref: Map.fetch!(map, "ref"), join_ref: Map.get(map, "join_ref") } rescue err in [KeyError] -> raise Phoenix.Socket.InvalidMessageError, "missing key #{inspect(err.key)}" end end defimpl Inspect do def inspect(%Phoenix.Socket.Message{} = msg, opts) do processed_msg = process_message(msg) Inspect.Any.inspect(processed_msg, opts) end defp process_message(%{payload: payload} = msg) when is_map(payload) do %{msg | payload: Phoenix.Logger.filter_values(payload)} end defp process_message(msg), do: msg end end defmodule Phoenix.Socket.Reply do @moduledoc """ Defines a reply sent from channels to transports. The message format requires the following keys: * `:topic` - The string topic or topic:subtopic pair namespace, for example "messages", "messages:123" * `:status` - The reply status as an atom * `:payload` - The reply payload * `:ref` - The unique string ref * `:join_ref` - The unique string ref when joining """ @type t :: %Phoenix.Socket.Reply{} defstruct topic: nil, status: nil, payload: nil, ref: nil, join_ref: nil end defmodule Phoenix.Socket.Broadcast do @moduledoc """ Defines a message sent from pubsub to channels and vice-versa. The message format requires the following keys: * `:topic` - The string topic or topic:subtopic pair namespace, for example "messages", "messages:123" * `:event`- The string event name, for example "phx_join" * `:payload` - The message payload """ @type t :: %Phoenix.Socket.Broadcast{} defstruct topic: nil, event: nil, payload: nil end ================================================ FILE: lib/phoenix/socket/pool_supervisor.ex ================================================ defmodule Phoenix.Socket.PoolSupervisor do @moduledoc false use Supervisor def start_link({endpoint, name, partitions}) do Supervisor.start_link( __MODULE__, {endpoint, name, partitions}, name: Module.concat(endpoint, name) ) end def start_child(socket, key, spec) do %{endpoint: endpoint, handler: name} = socket case endpoint.config({:socket, name}) do ets when not is_nil(ets) -> partitions = :ets.lookup_element(ets, :partitions, 2) sup = :ets.lookup_element(ets, :erlang.phash2(key, partitions), 2) DynamicSupervisor.start_child(sup, spec) nil -> raise ArgumentError, """ no socket supervision tree found for #{inspect(name)}. Ensure your #{inspect(endpoint)} contains a socket mount, for example: socket "/socket", #{inspect(name)}, websocket: true, longpoll: true """ end end def start_pooled(ref, i) do case DynamicSupervisor.start_link(strategy: :one_for_one) do {:ok, pid} -> :ets.insert(ref, {i, pid}) {:ok, pid} {:error, reason} -> {:error, reason} end end @impl true def init({endpoint, name, partitions}) do ref = :ets.new(name, [:public, read_concurrency: true]) :ets.insert(ref, {:partitions, partitions}) Phoenix.Config.permanent(endpoint, {:socket, name}, ref) children = for i <- 0..(partitions - 1) do %{ id: i, start: {__MODULE__, :start_pooled, [ref, i]}, type: :supervisor, shutdown: :infinity } end Supervisor.init(children, strategy: :one_for_one) end end defmodule Phoenix.Socket.PoolDrainer do @moduledoc false use GenServer def child_spec({_endpoint, name, opts} = tuple) do # The process should terminate within shutdown but, # in case it doesn't, we will be killed if we exceed # double of that %{ id: {:terminator, name}, start: {__MODULE__, :start_link, [tuple]}, shutdown: Keyword.get(opts[:drainer], :shutdown, 30_000) } end def start_link(tuple) do GenServer.start_link(__MODULE__, tuple) end @impl true def init({endpoint, name, opts}) do Process.flag(:trap_exit, true) size = Keyword.get(opts[:drainer], :batch_size, 10_000) interval = Keyword.get(opts[:drainer], :batch_interval, 2_000) log_level = Keyword.get(opts[:drainer], :log, opts[:log] || :info) {:ok, {endpoint, name, size, interval, log_level}} end @impl true def terminate(_reason, {endpoint, name, size, interval, log_level}) do ets = endpoint.config({:socket, name}) partitions = :ets.lookup_element(ets, :partitions, 2) {collection, total} = Enum.map_reduce(0..(partitions - 1), 0, fn index, total -> try do sup = :ets.lookup_element(ets, index, 2) children = DynamicSupervisor.which_children(sup) {Enum.map(children, &elem(&1, 1)), total + length(children)} catch _, _ -> {[], total} end end) rounds = div(total, size) + 1 for {pids, index} <- collection |> Stream.concat() |> Stream.chunk_every(size) |> Stream.with_index(1) do count = if index == rounds, do: length(pids), else: size :telemetry.execute( [:phoenix, :socket_drain], %{count: count, total: total, index: index, rounds: rounds}, %{ endpoint: endpoint, socket: name, interval: interval, log: log_level } ) spawn(fn -> for pid <- pids do send(pid, %Phoenix.Socket.Broadcast{event: "phx_drain"}) end end) if index < rounds do Process.sleep(interval) end end end end ================================================ FILE: lib/phoenix/socket/serializer.ex ================================================ defmodule Phoenix.Socket.Serializer do @moduledoc """ A behaviour that serializes incoming and outgoing socket messages. By default Phoenix provides a serializer that encodes to JSON and decodes JSON messages. Custom serializers may be configured in the socket. """ @doc """ Encodes a `Phoenix.Socket.Broadcast` struct to fastlane format. """ @callback fastlane!(Phoenix.Socket.Broadcast.t()) :: {:socket_push, :text, iodata()} | {:socket_push, :binary, iodata()} @doc """ Encodes `Phoenix.Socket.Message` and `Phoenix.Socket.Reply` structs to push format. """ @callback encode!(Phoenix.Socket.Message.t() | Phoenix.Socket.Reply.t()) :: {:socket_push, :text, iodata()} | {:socket_push, :binary, iodata()} @doc """ Decodes iodata into `Phoenix.Socket.Message` struct. """ @callback decode!(iodata, options :: Keyword.t()) :: Phoenix.Socket.Message.t() end ================================================ FILE: lib/phoenix/socket/serializers/v1_json_serializer.ex ================================================ defmodule Phoenix.Socket.V1.JSONSerializer do @moduledoc false @behaviour Phoenix.Socket.Serializer alias Phoenix.Socket.{Broadcast, Message, Reply} @impl true def fastlane!(%Broadcast{} = msg) do map = %Message{topic: msg.topic, event: msg.event, payload: msg.payload} {:socket_push, :text, encode_v1_fields_only(map)} end @impl true def encode!(%Reply{} = reply) do map = %Message{ topic: reply.topic, event: "phx_reply", ref: reply.ref, payload: %{status: reply.status, response: reply.payload} } {:socket_push, :text, encode_v1_fields_only(map)} end def encode!(%Message{} = map) do {:socket_push, :text, encode_v1_fields_only(map)} end @impl true def decode!(message, _opts) do payload = Phoenix.json_library().decode!(message) case payload do %{} -> Phoenix.Socket.Message.from_map!(payload) other -> raise "V1 JSON Serializer expected a map, got #{inspect(other)}" end end defp encode_v1_fields_only(%Message{} = msg) do msg |> Map.take([:topic, :event, :payload, :ref]) |> Phoenix.json_library().encode_to_iodata!() end end ================================================ FILE: lib/phoenix/socket/serializers/v2_json_serializer.ex ================================================ defmodule Phoenix.Socket.V2.JSONSerializer do @moduledoc false @behaviour Phoenix.Socket.Serializer @push 0 @reply 1 @broadcast 2 alias Phoenix.Socket.{Broadcast, Message, Reply} @impl true def fastlane!(%Broadcast{payload: {:binary, data}} = msg) do topic_size = byte_size!(msg.topic, :topic, 255) event_size = byte_size!(msg.event, :event, 255) bin = << @broadcast::size(8), topic_size::size(8), event_size::size(8), msg.topic::binary-size(topic_size), msg.event::binary-size(event_size), data::binary >> {:socket_push, :binary, bin} end def fastlane!(%Broadcast{payload: %{}} = msg) do data = Phoenix.json_library().encode_to_iodata!([nil, nil, msg.topic, msg.event, msg.payload]) {:socket_push, :text, data} end def fastlane!(%Broadcast{payload: invalid}) do raise ArgumentError, "expected broadcasted payload to be a map, got: #{inspect(invalid)}" end @impl true def encode!(%Reply{payload: {:binary, data}} = reply) do status = to_string(reply.status) join_ref = to_string(reply.join_ref) ref = to_string(reply.ref) join_ref_size = byte_size!(join_ref, :join_ref, 255) ref_size = byte_size!(ref, :ref, 255) topic_size = byte_size!(reply.topic, :topic, 255) status_size = byte_size!(status, :status, 255) bin = << @reply::size(8), join_ref_size::size(8), ref_size::size(8), topic_size::size(8), status_size::size(8), join_ref::binary-size(join_ref_size), ref::binary-size(ref_size), reply.topic::binary-size(topic_size), status::binary-size(status_size), data::binary >> {:socket_push, :binary, bin} end def encode!(%Reply{} = reply) do data = [ reply.join_ref, reply.ref, reply.topic, "phx_reply", %{status: reply.status, response: reply.payload} ] {:socket_push, :text, Phoenix.json_library().encode_to_iodata!(data)} end def encode!(%Message{payload: {:binary, data}} = msg) do join_ref = to_string(msg.join_ref) join_ref_size = byte_size!(join_ref, :join_ref, 255) topic_size = byte_size!(msg.topic, :topic, 255) event_size = byte_size!(msg.event, :event, 255) bin = << @push::size(8), join_ref_size::size(8), topic_size::size(8), event_size::size(8), join_ref::binary-size(join_ref_size), msg.topic::binary-size(topic_size), msg.event::binary-size(event_size), data::binary >> {:socket_push, :binary, bin} end def encode!(%Message{payload: %{}} = msg) do data = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload] {:socket_push, :text, Phoenix.json_library().encode_to_iodata!(data)} end def encode!(%Message{payload: invalid}) do raise ArgumentError, "expected payload to be a map, got: #{inspect(invalid)}" end @impl true def decode!(raw_message, opts) do case Keyword.fetch(opts, :opcode) do {:ok, :text} -> decode_text(raw_message) {:ok, :binary} -> decode_binary(raw_message) end end defp decode_text(raw_message) do [join_ref, ref, topic, event, payload | _] = Phoenix.json_library().decode!(raw_message) %Message{ topic: topic, event: event, payload: payload, ref: ref, join_ref: join_ref } end defp decode_binary(<< @push::size(8), join_ref_size::size(8), ref_size::size(8), topic_size::size(8), event_size::size(8), join_ref::binary-size(join_ref_size), ref::binary-size(ref_size), topic::binary-size(topic_size), event::binary-size(event_size), data::binary >>) do %Message{ topic: topic, event: event, payload: {:binary, data}, ref: ref, join_ref: join_ref } end defp byte_size!(bin, kind, max) do case byte_size(bin) do size when size <= max -> size oversized -> raise ArgumentError, """ unable to convert #{kind} to binary. #{inspect(bin)} must be less than or equal to #{max} bytes, but is #{oversized} bytes. """ end end end ================================================ FILE: lib/phoenix/socket/transport.ex ================================================ defmodule Phoenix.Socket.Transport do @moduledoc """ Outlines the Socket <-> Transport communication. Each transport, such as websockets and longpolling, must interact with a socket. This module defines the functions a transport will invoke on a given socket implementation. `Phoenix.Socket` is just one possible implementation of a socket that multiplexes events over multiple channels. If you implement this behaviour, then existing transports can use your new socket implementation, without passing through channels. This module also provides guidelines and convenience functions for implementing transports. Albeit its primary goal is to aid in the definition of custom sockets. ## Example Here is a simple echo socket implementation: defmodule EchoSocket do @behaviour Phoenix.Socket.Transport def child_spec(opts) do # We won't spawn any process, so let's ignore the child spec :ignore end def connect(state) do # Callback to retrieve relevant data from the connection. # The map contains options, params, transport and endpoint keys. {:ok, state} end def init(state) do # Now we are effectively inside the process that maintains the socket. {:ok, state} end def handle_in({text, _opts}, state) do {:reply, :ok, {:text, text}, state} end def handle_info(_, state) do {:ok, state} end def terminate(_reason, _state) do :ok end end It can be mounted in your endpoint like any other socket: socket "/socket", EchoSocket, websocket: true, longpoll: true You can now interact with the socket under `/socket/websocket` and `/socket/longpoll`. ## Custom transports Sockets are operated by a transport. When a transport is defined, it usually receives a socket module and the module will be invoked when certain events happen at the transport level. The functions a transport can invoke are the callbacks defined in this module. Whenever the transport receives a new connection, it should invoke the `c:connect/1` callback with a map of metadata. Different sockets may require different metadata. If the connection is accepted, the transport can move the connection to another process, if so desires, or keep using the same process. The process responsible for managing the socket should then call `c:init/1`. For each message received from the client, the transport must call `c:handle_in/2` on the socket. For each informational message the transport receives, it should call `c:handle_info/2` on the socket. Transports can optionally implement `c:handle_control/2` for handling control frames such as `:ping` and `:pong`. On termination, `c:terminate/2` must be called. A special atom with reason `:closed` can be used to specify that the client terminated the connection. ### Booting When you list a socket under `Phoenix.Endpoint.socket/3`, Phoenix will automatically start the socket module under its supervision tree, however Phoenix does not manage any transport. Whenever your endpoint starts, Phoenix invokes the `child_spec/1` on each listed socket and start that specification under the endpoint supervisor. Since the socket supervision tree is started by the endpoint, any custom transport must be started after the endpoint. """ @type state :: term() @doc """ Returns a child specification for socket management. This is invoked only once per socket regardless of the number of transports and should be responsible for setting up any process structure used exclusively by the socket regardless of transports. Each socket connection is started by the transport and the process that controls the socket likely belongs to the transport. However, some sockets spawn new processes, such as `Phoenix.Socket` which spawns channels, and this gives the ability to start a supervision tree associated to the socket. It receives the socket options from the endpoint, for example: socket "/my_app", MyApp.Socket, shutdown: 5000 means `child_spec([shutdown: 5000])` will be invoked. `:ignore` means no child spec is necessary for this socket. """ @callback child_spec(keyword) :: :supervisor.child_spec() | :ignore @doc """ Returns a child specification for terminating the socket. This is a process that is started late in the supervision tree with the specific goal of draining connections on application shutdown. Similar to `child_spec/1`, it receives the socket options from the endpoint. """ @callback drainer_spec(keyword) :: :supervisor.child_spec() | :ignore @doc """ Connects to the socket. The transport passes a map of metadata and the socket returns `{:ok, state}`, `{:error, reason}` or `:error`. The state must be stored by the transport and returned in all future operations. When `{:error, reason}` is returned, some transports - such as WebSockets - allow customizing the response based on `reason` via a custom `:error_handler`. This function is used for authorization purposes and it may be invoked outside of the process that effectively runs the socket. In the default `Phoenix.Socket` implementation, the metadata expects the following keys: * `:endpoint` - the application endpoint * `:transport` - the transport name * `:params` - the connection parameters * `:options` - a keyword list of transport options, often given by developers when configuring the transport. It must include a `:serializer` field with the list of serializers and their requirements """ @callback connect(transport_info :: map) :: {:ok, state} | {:error, term()} | :error @doc """ Initializes the socket state. This must be executed from the process that will effectively operate the socket. """ @callback init(state) :: {:ok, state} @doc """ Handles incoming socket messages. The message is represented as `{payload, options}`. It must return one of: * `{:ok, state}` - continues the socket with no reply * `{:reply, status, reply, state}` - continues the socket with reply * `{:stop, reason, state}` - stops the socket The `reply` is a tuple contain an `opcode` atom and a message that can be any term. The built-in websocket transport supports both `:text` and `:binary` opcode and the message must be always iodata. Long polling only supports text opcode. """ @callback handle_in({message :: term, opts :: keyword}, state) :: {:ok, state} | {:reply, :ok | :error, {opcode :: atom, message :: term}, state} | {:stop, reason :: term, state} @doc """ Handles incoming control frames. The message is represented as `{payload, options}`. It must return one of: * `{:ok, state}` - continues the socket with no reply * `{:reply, status, reply, state}` - continues the socket with reply * `{:stop, reason, state}` - stops the socket Control frames are only supported when using websockets. The `options` contains an `opcode` key, this will be either `:ping` or `:pong`. If a control frame doesn't have a payload, then the payload value will be `nil`. """ @callback handle_control({message :: term, opts :: keyword}, state) :: {:ok, state} | {:reply, :ok | :error, {opcode :: atom, message :: term}, state} | {:stop, reason :: term, state} @doc """ Handles info messages. The message is a term. It must return one of: * `{:ok, state}` - continues the socket with no reply * `{:push, reply, state}` - continues the socket with reply * `{:stop, reason, state}` - stops the socket The `reply` is a tuple contain an `opcode` atom and a message that can be any term. The built-in websocket transport supports both `:text` and `:binary` opcode and the message must be always iodata. Long polling only supports text opcode. """ @callback handle_info(message :: term, state) :: {:ok, state} | {:push, {opcode :: atom, message :: term}, state} | {:stop, reason :: term, state} @doc """ Invoked on termination. If `reason` is `:closed`, it means the client closed the socket. This is considered a `:normal` exit signal, so linked process will not automatically exit. See `Process.exit/2` for more details on exit signals. """ @callback terminate(reason :: term, state) :: :ok @optional_callbacks handle_control: 2, drainer_spec: 1 require Logger @doc false def load_config(true, module), do: module.default_config() def load_config(config, module), do: module.default_config() |> Keyword.merge(config) |> load_config() @doc false def load_config(config) do {connect_info, config} = Keyword.pop(config, :connect_info, []) connect_info = if config[:auth_token] do # auth_token is included by default when enabled [:auth_token | connect_info] else connect_info end connect_info = Enum.map(connect_info, fn key when key in [:peer_data, :trace_context_headers, :uri, :user_agent, :x_headers, :sec_websocket_headers, :auth_token] -> key {:session, session} -> {:session, init_session(session)} {_, _} = pair -> pair other -> raise ArgumentError, ":connect_info keys are expected to be one of :peer_data, :trace_context_headers, :x_headers, :user_agent, :sec_websocket_headers, :uri, or {:session, config}, " <> "optionally followed by custom keyword pairs, got: #{inspect(other)}" end) [connect_info: connect_info] ++ config end # The original session_config is returned in addition to init value so we can # access special config like :csrf_token_key downstream. defp init_session(session_config) when is_list(session_config) do key = Keyword.fetch!(session_config, :key) store = Plug.Session.Store.get(Keyword.fetch!(session_config, :store)) init = store.init(Keyword.drop(session_config, [:store, :key])) csrf_token_key = Keyword.get(session_config, :csrf_token_key, "_csrf_token") {key, store, {csrf_token_key, init}} end defp init_session({_, _, _} = mfa) do {:mfa, mfa} end @doc """ Runs the code reloader if enabled. """ def code_reload(conn, endpoint, opts) do if Keyword.get(opts, :code_reloader, endpoint.config(:code_reloader)) do Phoenix.CodeReloader.reload(endpoint) end conn end @doc """ Logs the transport request. Available for transports that generate a connection. """ def transport_log(conn, level) do if level do Plug.Logger.call(conn, Plug.Logger.init(log: level)) else conn end end @doc """ Checks the origin request header against the list of allowed origins. Should be called by transports before connecting when appropriate. If the origin header matches the allowed origins, no origin header was sent or no origin was configured, it will return the given connection. Otherwise a 403 Forbidden response will be sent and the connection halted. It is a noop if the connection has been halted. """ def check_origin(conn, handler, endpoint, opts, sender \\ &Plug.Conn.send_resp/1) def check_origin(%Plug.Conn{halted: true} = conn, _handler, _endpoint, _opts, _sender), do: conn def check_origin(conn, handler, endpoint, opts, sender) do import Plug.Conn origin = conn |> get_req_header("origin") |> List.first() check_origin = check_origin_config(handler, endpoint, opts) cond do is_nil(origin) or check_origin == false -> conn origin_allowed?(check_origin, URI.parse(origin), endpoint, conn) -> conn true -> Logger.error(""" Could not check origin for Phoenix.Socket transport. Origin of the request: #{origin} This happens when you are attempting a socket connection to a different host than the one configured in your config/ files. For example, in development the host is configured to "localhost" but you may be trying to access it from "127.0.0.1". To fix this issue, you may either: 1. update [url: [host: ...]] to your actual host in the config file for your current environment (recommended) 2. pass the :check_origin option when configuring your endpoint or when configuring the transport in your UserSocket module, explicitly outlining which origins are allowed: check_origin: ["https://example.com", "//another.com:888", "//other.com"] """) resp(conn, :forbidden, "") |> sender.() |> halt() end end @doc """ Checks the Websocket subprotocols request header against the allowed subprotocols. Should be called by transports before connecting when appropriate. If the sec-websocket-protocol header matches the allowed subprotocols, it will put sec-websocket-protocol response header and return the given connection. If no sec-websocket-protocol header was sent it will return the given connection. Otherwise a 403 Forbidden response will be sent and the connection halted. It is a noop if the connection has been halted. """ def check_subprotocols(conn, subprotocols) def check_subprotocols(%Plug.Conn{halted: true} = conn, _subprotocols), do: conn def check_subprotocols(conn, nil), do: conn def check_subprotocols(conn, subprotocols) when is_list(subprotocols) do case Plug.Conn.get_req_header(conn, "sec-websocket-protocol") do [] -> conn [subprotocols_header | _] -> request_subprotocols = subprotocols_header |> Plug.Conn.Utils.list() subprotocol = Enum.find(subprotocols, fn elem -> Enum.find(request_subprotocols, &(&1 == elem)) end) if subprotocol do Plug.Conn.put_resp_header(conn, "sec-websocket-protocol", subprotocol) else subprotocols_error_response(conn, subprotocols) end end end def check_subprotocols(conn, subprotocols), do: subprotocols_error_response(conn, subprotocols) defp subprotocols_error_response(conn, subprotocols) do import Plug.Conn request_headers = get_req_header(conn, "sec-websocket-protocol") Logger.error(""" Could not check Websocket subprotocols for Phoenix.Socket transport. Subprotocols of the request: #{inspect(request_headers)} Configured supported subprotocols: #{inspect(subprotocols)} This happens when you are attempting a socket connection to a different subprotocols than the one configured in your endpoint or when you incorrectly configured supported subprotocols. To fix this issue, you may either: 1. update websocket: [subprotocols: [..]] to your actual subprotocols in your endpoint socket configuration. 2. check the correctness of the `sec-websocket-protocol` request header sent from the client. 3. remove `websocket` option from your endpoint socket configuration if you don't use Websocket subprotocols. """) resp(conn, :forbidden, "") |> send_resp() |> halt() end @doc """ Extracts connection information from `conn` and returns a map. Keys are retrieved from the optional transport option `:connect_info`. This functionality is transport specific. Please refer to your transports' documentation for more information. The supported keys are: * `:peer_data` - the result of `Plug.Conn.get_peer_data/1` * `:trace_context_headers` - a list of all trace context headers * `:x_headers` - a list of all request headers that have an "x-" prefix * `:uri` - a `%URI{}` derived from the conn * `:user_agent` - the value of the "user-agent" request header * `:sec_websocket_headers` - a list of all request headers that have a "sec-websocket-" prefix The CSRF check can be disabled by setting the `:check_csrf` option to `false`. """ def connect_info(conn, endpoint, keys, opts \\ []) do for key <- keys, into: %{} do case key do :peer_data -> {:peer_data, Plug.Conn.get_peer_data(conn)} :trace_context_headers -> {:trace_context_headers, fetch_trace_context_headers(conn)} :x_headers -> {:x_headers, fetch_headers(conn, "x-")} :uri -> {:uri, fetch_uri(conn)} :user_agent -> {:user_agent, fetch_user_agent(conn)} :sec_websocket_headers -> {:sec_websocket_headers, fetch_headers(conn, "sec-websocket-")} {:session, session} -> {:session, connect_session(conn, endpoint, session, opts)} :auth_token -> {:auth_token, conn.private[:phoenix_transport_auth_token]} {key, val} -> {key, val} end end end defp connect_session(conn, endpoint, {key, store, {csrf_token_key, init}}, opts) do conn = Plug.Conn.fetch_cookies(conn) check_csrf = Keyword.get(opts, :check_csrf, true) with cookie when is_binary(cookie) <- conn.cookies[key], conn = put_in(conn.secret_key_base, endpoint.config(:secret_key_base)), {_, session} <- store.get(conn, cookie, init), true <- not check_csrf or csrf_token_valid?(conn, session, csrf_token_key) do session else _ -> nil end end defp connect_session(conn, endpoint, {:mfa, {module, function, args}}, opts) do case apply(module, function, args) do session_config when is_list(session_config) -> connect_session(conn, endpoint, init_session(session_config), opts) other -> raise ArgumentError, "the MFA given to `session_config` must return a keyword list, got: #{inspect(other)}" end end defp fetch_headers(conn, prefix) do for {header, _} = pair <- conn.req_headers, String.starts_with?(header, prefix), do: pair end defp fetch_trace_context_headers(conn) do for {header, _} = pair <- conn.req_headers, header in ["traceparent", "tracestate"], do: pair end defp fetch_uri(conn) do %URI{ scheme: to_string(conn.scheme), query: conn.query_string, port: conn.port, host: conn.host, authority: conn.host, path: conn.request_path } end defp fetch_user_agent(conn) do with {_, value} <- List.keyfind(conn.req_headers, "user-agent", 0) do value end end defp csrf_token_valid?(conn, session, csrf_token_key) do with csrf_token when is_binary(csrf_token) <- conn.params["_csrf_token"], csrf_state when is_binary(csrf_state) <- Plug.CSRFProtection.dump_state_from_session(session[csrf_token_key]) do Plug.CSRFProtection.valid_state_and_csrf_token?(csrf_state, csrf_token) end end defp check_origin_config(handler, endpoint, opts) do Phoenix.Config.cache(endpoint, {:check_origin, handler}, fn _ -> check_origin = case Keyword.get(opts, :check_origin, endpoint.config(:check_origin)) do origins when is_list(origins) -> Enum.map(origins, &parse_origin/1) boolean when is_boolean(boolean) -> boolean {module, function, arguments} -> {module, function, arguments} :conn -> :conn invalid -> raise ArgumentError, ":check_origin expects a boolean, list of hosts, :conn, or MFA tuple, got: #{inspect(invalid)}" end {:cache, check_origin} end) end defp parse_origin(origin) do case URI.parse(origin) do %{host: nil} -> raise ArgumentError, "invalid :check_origin option: #{inspect(origin)}. " <> "Expected an origin with a host that is parsable by URI.parse/1. For example: " <> "[\"https://example.com\", \"//another.com:888\", \"//other.com\"]" %{scheme: scheme, port: port, host: host} -> {scheme, host, port} end end defp origin_allowed?({module, function, arguments}, uri, _endpoint, _conn), do: apply(module, function, [uri | arguments]) defp origin_allowed?(:conn, uri, _endpoint, %Plug.Conn{} = conn) do uri.host == conn.host and uri.scheme == Atom.to_string(conn.scheme) and uri.port == conn.port end defp origin_allowed?(_check_origin, %{host: nil}, _endpoint, _conn), do: false defp origin_allowed?(true, uri, endpoint, _conn), do: compare?(uri.host, host_to_binary(endpoint.config(:url)[:host])) defp origin_allowed?(check_origin, uri, _endpoint, _conn) when is_list(check_origin), do: origin_allowed?(uri, check_origin) defp origin_allowed?(uri, allowed_origins) do %{scheme: origin_scheme, host: origin_host, port: origin_port} = uri Enum.any?(allowed_origins, fn {allowed_scheme, allowed_host, allowed_port} -> compare?(origin_scheme, allowed_scheme) and compare?(origin_port, allowed_port) and compare_host?(origin_host, allowed_host) end) end defp compare?(request_val, allowed_val) do is_nil(allowed_val) or request_val == allowed_val end defp compare_host?(_request_host, nil), do: true defp compare_host?(request_host, "*." <> allowed_host), do: request_host == allowed_host or String.ends_with?(request_host, "." <> allowed_host) defp compare_host?(request_host, allowed_host), do: request_host == allowed_host # TODO: Remove this once {:system, env_var} deprecation is removed defp host_to_binary({:system, env_var}), do: host_to_binary(System.get_env(env_var)) defp host_to_binary(host), do: host end ================================================ FILE: lib/phoenix/socket.ex ================================================ defmodule Phoenix.Socket do @moduledoc ~S""" A socket implementation that multiplexes messages over channels. `Phoenix.Socket` is used as a module for establishing a connection between client and server. Once the connection is established, the initial state is stored in the `Phoenix.Socket` struct. The same socket can be used to receive events from different transports. Phoenix supports `websocket` and `longpoll` options when invoking `Phoenix.Endpoint.socket/3` in your endpoint. `websocket` is set by default and `longpoll` can also be configured explicitly. socket "/socket", MyAppWeb.Socket, websocket: true, longpoll: false The command above means incoming socket connections can be made via a WebSocket connection. Incoming and outgoing events are routed to channels by topic: channel "room:lobby", MyAppWeb.LobbyChannel See `Phoenix.Channel` for more information on channels. ## Socket Behaviour Socket handlers are mounted in Endpoints and must define two callbacks: * `connect/3` - receives the socket params, connection info if any, and authenticates the connection. Must return a `Phoenix.Socket` struct, often with custom assigns * `id/1` - receives the socket returned by `connect/3` and returns the id of this connection as a string. The `id` is used to identify socket connections, often to a particular user, allowing us to force disconnections. For sockets requiring no authentication, `nil` can be returned ## Examples defmodule MyAppWeb.UserSocket do use Phoenix.Socket channel "room:*", MyAppWeb.RoomChannel def connect(params, socket, _connect_info) do {:ok, assign(socket, :user_id, params["user_id"])} end def id(socket), do: "users_socket:#{socket.assigns.user_id}" end # Disconnect all user's socket connections and their multiplexed channels MyAppWeb.Endpoint.broadcast("users_socket:" <> user.id, "disconnect", %{}) ## Socket fields * `:id` - The string id of the socket * `:assigns` - The map of socket assigns, default: `%{}` * `:channel` - The current channel module * `:channel_pid` - The channel pid * `:endpoint` - The endpoint module where this socket originated, for example: `MyAppWeb.Endpoint` * `:handler` - The socket module where this socket originated, for example: `MyAppWeb.UserSocket` * `:joined` - If the socket has effectively joined the channel * `:join_ref` - The ref sent by the client when joining * `:ref` - The latest ref sent by the client * `:pubsub_server` - The registered name of the socket's pubsub server * `:topic` - The string topic, for example `"room:123"` * `:transport` - An identifier for the transport, used for logging * `:transport_pid` - The pid of the socket's transport process * `:serializer` - The serializer for socket messages ## Using options On `use Phoenix.Socket`, the following options are accepted: * `:log` - the default level to log socket actions. Defaults to `:info`. May be set to `false` to disable it * `:partitions` - each channel is spawned under a supervisor. This option controls how many supervisors will be spawned to handle channels. Defaults to the number of cores. ## Garbage collection It's possible to force garbage collection in the transport process after processing large messages. For example, to trigger such from your channels, run: send(socket.transport_pid, :garbage_collect) Alternatively, you can configure your endpoint socket to trigger more fullsweep garbage collections more frequently, by setting the `:fullsweep_after` option for websockets. See `Phoenix.Endpoint.socket/3` for more info. ## Client-server communication The encoding of server data and the decoding of client data is done according to a serializer, defined in `Phoenix.Socket.Serializer`. By default, JSON encoding is used to broker messages to and from clients. The serializer `decode!` function must return a `Phoenix.Socket.Message` which is forwarded to channels except: * `"heartbeat"` events in the "phoenix" topic - should just emit an OK reply * `"phx_join"` on any topic - should join the topic * `"phx_leave"` on any topic - should leave the topic Each message also has a `ref` field which is used to track responses. The server may send messages or replies back. For messages, the ref uniquely identifies the message. For replies, the ref matches the original message. Both data-types also include a join_ref that uniquely identifies the currently joined channel. The `Phoenix.Socket` implementation may also send special messages and replies: * `"phx_error"` - in case of errors, such as a channel process crashing, or when attempting to join an already joined channel * `"phx_close"` - the channel was gracefully closed Phoenix ships with a JavaScript implementation of both websocket and long polling that interacts with Phoenix.Socket and can be used as reference for those interested in implementing custom clients. ## Custom sockets and transports See the `Phoenix.Socket.Transport` documentation for more information on writing your own socket that does not leverage channels or for writing your own transports that interacts with other sockets. ## Custom channels You can list any module as a channel as long as it implements a `child_spec/1` function. The `child_spec/1` function receives the caller as argument and it must return a child spec that initializes a process. Once the process is initialized, it will receive the following message: {Phoenix.Channel, auth_payload, from, socket} A custom channel implementation MUST invoke `GenServer.reply(from, {:ok | :error, reply_payload})` during its initialization with a custom `reply_payload` that will be sent as a reply to the client. Failing to do so will block the socket forever. A custom channel receives `Phoenix.Socket.Message` structs as regular messages from the transport. Replies to those messages and custom messages can be sent to the socket at any moment by building an appropriate `Phoenix.Socket.Reply` and `Phoenix.Socket.Message` structs, encoding them with the serializer and dispatching the serialized result to the transport. For example, to handle "phx_leave" messages, which is recommended to be handled by all channel implementations, one may do: def handle_info( %Message{topic: topic, event: "phx_leave"} = message, %{topic: topic, serializer: serializer, transport_pid: transport_pid} = socket ) do send transport_pid, serializer.encode!(build_leave_reply(message)) {:stop, {:shutdown, :left}, socket} end A special message delivered to all channels is a Broadcast with event "phx_drain", which is sent when draining the socket during application shutdown. Typically it is handled by sending a drain message to the transport, causing it to shutdown: def handle_info( %Broadcast{event: "phx_drain"}, %{transport_pid: transport_pid} = socket ) do send(transport_pid, :socket_drain) {:stop, {:shutdown, :draining}, socket} end We also recommend all channels to monitor the `transport_pid` on `init` and exit if the transport exits. We also advise to rewrite `:normal` exit reasons (usually due to the socket being closed) to the `{:shutdown, :closed}` to guarantee links are broken on the channel exit (as a `:normal` exit does not break links): def handle_info({:DOWN, _, _, transport_pid, reason}, %{transport_pid: transport_pid} = socket) do reason = if reason == :normal, do: {:shutdown, :closed}, else: reason {:stop, reason, socket} end Any process exit is treated as an error by the socket layer unless a `{:socket_close, pid, reason}` message is sent to the socket before shutdown. Custom channel implementations cannot be tested with `Phoenix.ChannelTest`. """ require Logger alias Phoenix.Socket alias Phoenix.Socket.{Broadcast, Message, Reply} @doc """ Receives the socket params and authenticates the connection. ## Socket params and assigns Socket params are passed from the client and can be used to verify and authenticate a user. After verification, you can put default assigns into the socket that will be set for all channels, ie {:ok, assign(socket, :user_id, verified_user_id)} To deny connection, return `:error` or `{:error, term}`. To control the response the client receives in that case, [define an error handler in the websocket configuration](https://hexdocs.pm/phoenix/Phoenix.Endpoint.html#socket/3-websocket-configuration). See `Phoenix.Token` documentation for examples in performing token verification on connect. """ @callback connect(params :: map, Socket.t(), connect_info :: map) :: {:ok, Socket.t()} | {:error, term} | :error @doc """ Shortcut version of `connect/3` which does not receive `connect_info`. Provided for backwards compatibility. """ @callback connect(params :: map, Socket.t()) :: {:ok, Socket.t()} | {:error, term} | :error @doc ~S""" Identifies the socket connection. Socket IDs are topics that allow you to identify all sockets for a given user: def id(socket), do: "users_socket:#{socket.assigns.user_id}" Would allow you to broadcast a `"disconnect"` event and terminate all active sockets and channels for a given user: MyAppWeb.Endpoint.broadcast("users_socket:" <> user.id, "disconnect", %{}) Returning `nil` makes this socket anonymous. """ @callback id(Socket.t()) :: String.t() | nil @optional_callbacks connect: 2, connect: 3 defmodule InvalidMessageError do @moduledoc """ Raised when the socket message is invalid. """ defexception [:message] end defstruct assigns: %{}, channel: nil, channel_pid: nil, endpoint: nil, handler: nil, id: nil, joined: false, join_ref: nil, private: %{}, pubsub_server: nil, ref: nil, serializer: nil, topic: nil, transport: nil, transport_pid: nil @type t :: %Socket{ assigns: map, channel: atom, channel_pid: pid, endpoint: atom, handler: atom, id: String.t() | nil, joined: boolean, ref: term, private: map, pubsub_server: atom, serializer: atom, topic: String.t(), transport: atom, transport_pid: pid } defmacro __using__(opts) do quote do ## User API import Phoenix.Socket @behaviour Phoenix.Socket @before_compile Phoenix.Socket Module.register_attribute(__MODULE__, :phoenix_channels, accumulate: true) @phoenix_socket_options unquote(opts) ## Callbacks @behaviour Phoenix.Socket.Transport @doc false def child_spec(opts) do Phoenix.Socket.__child_spec__(__MODULE__, opts, @phoenix_socket_options) end @doc false def drainer_spec(opts) do Phoenix.Socket.__drainer_spec__(__MODULE__, opts, @phoenix_socket_options) end @doc false def connect(map), do: Phoenix.Socket.__connect__(__MODULE__, map, @phoenix_socket_options) @doc false def init(state), do: Phoenix.Socket.__init__(state) @doc false def handle_in(message, state), do: Phoenix.Socket.__in__(message, state) @doc false def handle_info(message, state), do: Phoenix.Socket.__info__(message, state) @doc false def terminate(reason, state), do: Phoenix.Socket.__terminate__(reason, state) end end ## USER API @doc """ Adds a `key`/`value` pair to `socket` assigns. See also `assign/2` to add multiple key/value pairs. ## Examples iex> assign(socket, :name, "Elixir") """ def assign(%Socket{} = socket, key, value) do assign(socket, [{key, value}]) end @doc """ Adds key/value pairs to socket assigns. Accepts a keyword list, a map, or a single-argument function. When a keyword list or map is provided, it will be merged into the existing assigns. If a function is given, it takes the current assigns as an argument and its return value will be merged into the current assigns. ## Examples iex> assign(socket, name: "Elixir", logo: "💧") iex> assign(socket, %{name: "Elixir"}) iex> assign(socket, fn %{name: name, logo: logo} -> %{title: Enum.join([name, logo], " | ")} end) """ def assign(%Socket{} = socket, keyword_or_map) when is_map(keyword_or_map) or is_list(keyword_or_map) do %{socket | assigns: Map.merge(socket.assigns, Map.new(keyword_or_map))} end def assign(%Socket{} = socket, fun) when is_function(fun, 1) do assign(socket, fun.(socket.assigns)) end @doc """ Defines a channel matching the given topic and transports. * `topic_pattern` - The string pattern, for example `"room:*"`, `"users:*"`, or `"system"` * `module` - The channel module handler, for example `MyAppWeb.RoomChannel` * `opts` - The optional list of options, see below ## Options * `:assigns` - the map of socket assigns to merge into the socket on join ## Examples channel "topic1:*", MyChannel ## Topic Patterns The `channel` macro accepts topic patterns in two flavors. A splat (the `*` character) argument can be provided as the last character to indicate a `"topic:subtopic"` match. If a plain string is provided, only that topic will match the channel handler. Most use-cases will use the `"topic:*"` pattern to allow more versatile topic scoping. See `Phoenix.Channel` for more information """ defmacro channel(topic_pattern, module, opts \\ []) do module = expand_alias(module, __CALLER__) opts = if Macro.quoted_literal?(opts) do Macro.prewalk(opts, &expand_alias(&1, __CALLER__)) else opts end quote do @phoenix_channels {unquote(topic_pattern), unquote(module), unquote(opts)} end end defp expand_alias({:__aliases__, _, _} = alias, env), do: Macro.expand(alias, %{env | function: {:channel, 3}}) defp expand_alias(other, _env), do: other @doc false @deprecated "transport/3 in Phoenix.Socket is deprecated and has no effect" defmacro transport(_name, _module, _config \\ []) do :ok end defmacro __before_compile__(env) do channels = env.module |> Module.get_attribute(:phoenix_channels, []) |> Enum.reverse() channel_defs = for {topic_pattern, module, opts} <- channels do topic_pattern |> to_topic_match() |> defchannel(module, opts) end quote do unquote(channel_defs) def __channel__(_topic), do: nil end end defp to_topic_match(topic_pattern) do case String.split(topic_pattern, "*") do [prefix, ""] -> quote do: < _rest>> [bare_topic] -> bare_topic _ -> raise ArgumentError, "channels using splat patterns must end with *" end end defp defchannel(topic_match, channel_module, opts) do quote do def __channel__(unquote(topic_match)), do: unquote({channel_module, Macro.escape(opts)}) end end ## CALLBACKS IMPLEMENTATION def __child_spec__(handler, opts, socket_options) do endpoint = Keyword.fetch!(opts, :endpoint) opts = Keyword.merge(socket_options, opts) partitions = Keyword.get(opts, :partitions, System.schedulers_online()) args = {endpoint, handler, partitions} Supervisor.child_spec({Phoenix.Socket.PoolSupervisor, args}, id: handler) end def __drainer_spec__(handler, opts, socket_options) do endpoint = Keyword.fetch!(opts, :endpoint) opts = Keyword.merge(socket_options, opts) if drainer = Keyword.get(opts, :drainer, []) do drainer = case drainer do {module, function, arguments} -> apply(module, function, arguments) _ -> drainer end opts = Keyword.merge(opts, drainer: drainer) {Phoenix.Socket.PoolDrainer, {endpoint, handler, opts}} else :ignore end end def __connect__(user_socket, map, socket_options) do %{ endpoint: endpoint, options: options, transport: transport, params: params, connect_info: connect_info } = map vsn = params["vsn"] || "1.0.0" options = Keyword.merge(socket_options, options) start = System.monotonic_time() case negotiate_serializer(Keyword.fetch!(options, :serializer), vsn) do {:ok, serializer} -> result = user_connect(user_socket, endpoint, transport, serializer, params, connect_info) metadata = %{ endpoint: endpoint, transport: transport, params: params, connect_info: connect_info, vsn: vsn, user_socket: user_socket, log: Keyword.get(options, :log, :info), result: result(result), serializer: serializer } duration = System.monotonic_time() - start :telemetry.execute([:phoenix, :socket_connected], %{duration: duration}, metadata) result :error -> :error end end defp result({:ok, _}), do: :ok defp result(:error), do: :error defp result({:error, _}), do: :error defp set_label(socket) do # TODO: replace with Process.put_label/2 when we require Elixir 1.17 Process.put(:"$process_label", {Phoenix.Socket, socket.handler, socket.id}) end def __init__({state, %{id: id, endpoint: endpoint} = socket}) do set_label(socket) _ = id && endpoint.subscribe(id) {:ok, {state, %{socket | transport_pid: self()}}} end def __in__({payload, opts}, {state, socket}) do %{topic: topic} = message = socket.serializer.decode!(payload, opts) handle_in(Map.get(state.channels, topic), message, state, socket) end def __info__({:DOWN, ref, _, pid, reason}, {state, socket}) do case state.channels_inverse do %{^pid => {topic, join_ref}} -> state = delete_channel(state, pid, topic, ref) {:push, encode_on_exit(socket, topic, join_ref, reason), {state, socket}} %{} -> {:ok, {state, socket}} end end def __info__(%Broadcast{event: "disconnect"}, state) do {:stop, {:shutdown, :disconnected}, state} end def __info__(:socket_drain, state) do # downstream websock_adapter's will close with 1012 Service Restart {:stop, {:shutdown, :restart}, state} end def __info__({:socket_push, opcode, payload}, state) do {:push, {opcode, payload}, state} end def __info__({:socket_close, pid, _reason}, state) do socket_close(pid, state) end def __info__(:garbage_collect, state) do :erlang.garbage_collect(self()) {:ok, state} end def __info__({:debug_channels, ref, reply_to}, {state, socket}) do channels = Enum.map(state.channels, fn {topic, {pid, _monitor_ref, status}} -> %{topic: topic, pid: pid, status: status} end) send(reply_to, {:debug_channels, ref, channels}) {:ok, {state, socket}} end def __info__(_, state) do {:ok, state} end def __terminate__(_reason, _state_socket) do :ok end defp negotiate_serializer(serializers, vsn) when is_list(serializers) do case Version.parse(vsn) do {:ok, vsn} -> serializers |> Enum.find(:error, fn {_serializer, vsn_req} -> Version.match?(vsn, vsn_req) end) |> case do {serializer, _vsn_req} -> {:ok, serializer} :error -> Logger.warning( "The client's requested transport version \"#{vsn}\" " <> "does not match server's version requirements of #{inspect(serializers)}" ) :error end :error -> Logger.warning("Client sent invalid transport version \"#{vsn}\"") :error end end defp user_connect(handler, endpoint, transport, serializer, params, connect_info) do # The information in the Phoenix.Socket goes to userland and channels. socket = %Socket{ handler: handler, endpoint: endpoint, pubsub_server: endpoint.config(:pubsub_server), serializer: serializer, transport: transport } # The information in the state is kept only inside the socket process. state = %{ channels: %{}, channels_inverse: %{} } connect_result = if function_exported?(handler, :connect, 3) do handler.connect(params, socket, connect_info) else handler.connect(params, socket) end case connect_result do {:ok, %Socket{} = socket} -> case handler.id(socket) do nil -> {:ok, {state, socket}} id when is_binary(id) -> # update the process label set_label(socket) {:ok, {state, %{socket | id: id}}} invalid -> Logger.warning( "#{inspect(handler)}.id/1 returned invalid identifier " <> "#{inspect(invalid)}. Expected nil or a string." ) :error end :error -> :error {:error, _reason} = err -> err invalid -> connect_arity = if function_exported?(handler, :connect, 3), do: "connect/3", else: "connect/2" Logger.error( "#{inspect(handler)}. #{connect_arity} returned invalid value #{inspect(invalid)}. " <> "Expected {:ok, socket}, {:error, reason} or :error" ) :error end end defp handle_in(_, %{ref: ref, topic: "phoenix", event: "heartbeat"}, state, socket) do reply = %Reply{ ref: ref, topic: "phoenix", status: :ok, payload: %{} } {:reply, :ok, encode_reply(socket, reply), {state, socket}} end defp handle_in( nil, %{event: "phx_join", topic: topic, ref: ref, join_ref: join_ref} = message, state, socket ) do case socket.handler.__channel__(topic) do {channel, opts} -> case Phoenix.Channel.Server.join(socket, channel, message, opts) do {:ok, reply, pid} -> reply = %Reply{ join_ref: join_ref, ref: ref, topic: topic, status: :ok, payload: reply } state = put_channel(state, pid, topic, join_ref) {:reply, :ok, encode_reply(socket, reply), {state, socket}} {:error, reply} -> reply = %Reply{ join_ref: join_ref, ref: ref, topic: topic, status: :error, payload: reply } {:reply, :error, encode_reply(socket, reply), {state, socket}} end _ -> Logger.warning("Ignoring unmatched topic \"#{topic}\" in #{inspect(socket.handler)}") {:reply, :error, encode_ignore(socket, message), {state, socket}} end end defp handle_in({pid, _ref, status}, %{event: "phx_join", topic: topic} = message, state, socket) do receive do {:socket_close, ^pid, _reason} -> :ok after 0 -> if status != :leaving do Logger.debug(fn -> "Duplicate channel join for topic \"#{topic}\" in #{inspect(socket.handler)}. " <> "Closing existing channel for new join." end) end end :ok = shutdown_duplicate_channel(pid) {:push, {opcode, payload}, {new_state, new_socket}} = socket_close(pid, {state, socket}) send(self(), {:socket_push, opcode, payload}) handle_in(nil, message, new_state, new_socket) end defp handle_in({pid, _ref, _status}, %{event: "phx_leave"} = msg, state, socket) do %{topic: topic, join_ref: join_ref} = msg case state.channels_inverse do # we need to match on nil to handle v1 protocol %{^pid => {^topic, existing_join_ref}} when existing_join_ref in [join_ref, nil] -> send(pid, msg) {:ok, {update_channel_status(state, pid, topic, :leaving), socket}} # the client has raced a server close. No need to reply since we already sent close %{^pid => {^topic, _old_join_ref}} -> {:ok, {state, socket}} end end defp handle_in({pid, _ref, _status}, msg, state, socket) do %{topic: topic, join_ref: join_ref} = msg case state.channels_inverse do # we need to match on nil to handle v1 protocol %{^pid => {^topic, existing_join_ref}} when existing_join_ref in [join_ref, nil] -> send(pid, msg) {:ok, {state, socket}} # the client has sent a stale message to a previous join_ref, ignore %{^pid => {^topic, _old_join_ref}} -> {:ok, {state, socket}} end end defp handle_in( nil, %{event: "phx_leave", ref: ref, topic: topic, join_ref: join_ref}, state, socket ) do reply = %Reply{ ref: ref, join_ref: join_ref, topic: topic, status: :ok, payload: %{} } {:reply, :ok, encode_reply(socket, reply), {state, socket}} end defp handle_in(nil, message, state, socket) do # This clause can happen if the server drops the channel # and the client sends a message meanwhile {:reply, :error, encode_ignore(socket, message), {state, socket}} end defp put_channel(state, pid, topic, join_ref) do %{channels: channels, channels_inverse: channels_inverse} = state monitor_ref = Process.monitor(pid) %{ state | channels: Map.put(channels, topic, {pid, monitor_ref, :joined}), channels_inverse: Map.put(channels_inverse, pid, {topic, join_ref}) } end defp delete_channel(state, pid, topic, monitor_ref) do %{channels: channels, channels_inverse: channels_inverse} = state Process.demonitor(monitor_ref, [:flush]) %{ state | channels: Map.delete(channels, topic), channels_inverse: Map.delete(channels_inverse, pid) } end defp encode_on_exit(socket, topic, ref, _reason) do message = %Message{join_ref: ref, ref: ref, topic: topic, event: "phx_error", payload: %{}} encode_reply(socket, message) end defp encode_ignore(socket, %{ref: ref, topic: topic}) do reply = %Reply{ref: ref, topic: topic, status: :error, payload: %{reason: "unmatched topic"}} encode_reply(socket, reply) end defp encode_reply(%{serializer: serializer}, message) do {:socket_push, opcode, payload} = serializer.encode!(message) {opcode, payload} end defp encode_close(socket, topic, join_ref) do message = %Message{ join_ref: join_ref, ref: join_ref, topic: topic, event: "phx_close", payload: %{} } encode_reply(socket, message) end defp shutdown_duplicate_channel(pid) do ref = Process.monitor(pid) Process.exit(pid, {:shutdown, :duplicate_join}) receive do {:DOWN, ^ref, _, _, _} -> :ok after 5_000 -> Process.exit(pid, :kill) receive do: ({:DOWN, ^ref, _, _, _} -> :ok) end end defp socket_close(pid, {state, socket}) do case state.channels_inverse do %{^pid => {topic, join_ref}} -> {^pid, monitor_ref, _status} = Map.fetch!(state.channels, topic) state = delete_channel(state, pid, topic, monitor_ref) {:push, encode_close(socket, topic, join_ref), {state, socket}} %{} -> {:ok, {state, socket}} end end defp update_channel_status(state, pid, topic, status) do new_channels = Map.update!(state.channels, topic, fn {^pid, ref, _} -> {pid, ref, status} end) %{state | channels: new_channels} end end ================================================ FILE: lib/phoenix/test/channel_test.ex ================================================ defmodule Phoenix.ChannelTest do @moduledoc """ Conveniences for testing Phoenix channels. In channel tests, we interact with channels via process communication, sending and receiving messages. It is also common to subscribe to the same topic the channel subscribes to, allowing us to assert if a given message was broadcast or not. ## Channel testing To get started, define the module attribute `@endpoint` in your test case pointing to your application endpoint. Then you can directly create a socket and `subscribe_and_join/4` topics and channels: {:ok, _, socket} = socket(UserSocket, "user:id", %{some_assigns: 1}) |> subscribe_and_join(RoomChannel, "room:lobby", %{"id" => 3}) You usually want to set the same ID and assigns your `UserSocket.connect/3` callback would set. Alternatively, you can use the `connect/3` helper to call your `UserSocket.connect/3` callback and initialize the socket with the socket id: {:ok, socket} = connect(UserSocket, %{"some" => "params"}, %{}) {:ok, _, socket} = subscribe_and_join(socket, "room:lobby", %{"id" => 3}) Once called, `subscribe_and_join/4` will subscribe the current test process to the "room:lobby" topic and start a channel in another process. It returns `{:ok, reply, socket}` or `{:error, reply}`. Now, in the same way the channel has a socket representing communication it will push to the client. Our test has a socket representing communication to be pushed to the server. For example, we can use the `push/3` function in the test to push messages to the channel (it will invoke `handle_in/3`): push(socket, "my_event", %{"some" => "data"}) Similarly, we can broadcast messages from the test itself on the topic that both test and channel are subscribed to, triggering `handle_out/3` on the channel: broadcast_from(socket, "my_event", %{"some" => "data"}) > Note only `broadcast_from/3` and `broadcast_from!/3` are available in tests to avoid broadcast messages to be resent to the test process. While the functions above are pushing data to the channel (server) we can use `assert_push/3` to verify the channel pushed a message to the client: assert_push "my_event", %{"some" => "data"} Or even assert something was broadcast into pubsub: assert_broadcast "my_event", %{"some" => "data"} Finally, every time a message is pushed to the channel, a reference is returned. We can use this reference to assert a particular reply was sent from the server: ref = push(socket, "counter", %{}) assert_reply ref, :ok, %{"counter" => 1} ## Checking side-effects Often one may want to do side-effects inside channels, like writing to the database, and verify those side-effects during their tests. Imagine the following `handle_in/3` inside a channel: def handle_in("publish", %{"id" => id}, socket) do Repo.get!(Post, id) |> Post.publish() |> Repo.update!() {:noreply, socket} end Because the whole communication is asynchronous, the following test would be very brittle: push(socket, "publish", %{"id" => 3}) assert Repo.get_by(Post, id: 3, published: true) The issue is that we have no guarantees the channel has done processing our message after calling `push/3`. The best solution is to assert the channel sent us a reply before doing any other assertion. First change the channel to send replies: def handle_in("publish", %{"id" => id}, socket) do Repo.get!(Post, id) |> Post.publish() |> Repo.update!() {:reply, :ok, socket} end Then expect them in the test: ref = push(socket, "publish", %{"id" => 3}) assert_reply ref, :ok assert Repo.get_by(Post, id: 3, published: true) ## Leave and close This module also provides functions to simulate leaving and closing a channel. Once you leave or close a channel, because the channel is linked to the test process on join, it will crash the test process: leave(socket) ** (EXIT from #PID<...>) {:shutdown, :leave} You can avoid this by unlinking the channel process in the test: Process.unlink(socket.channel_pid) Notice `leave/1` is async, so it will also return a reference which you can use to check for a reply: ref = leave(socket) assert_reply ref, :ok On the other hand, close is always sync and it will return only after the channel process is guaranteed to have been terminated: :ok = close(socket) This mimics the behaviour existing in clients. To assert that your channel closes or errors asynchronously, you can monitor the channel process with the tools provided by Elixir, and wait for the `:DOWN` message. Imagine an implementation of the `handle_info/2` function that closes the channel when it receives `:some_message`: def handle_info(:some_message, socket) do {:stop, :normal, socket} end In your test, you can assert that the close happened by: Process.monitor(socket.channel_pid) send(socket.channel_pid, :some_message) assert_receive {:DOWN, _, _, _, :normal} """ alias Phoenix.Socket alias Phoenix.Socket.{Broadcast, Message, Reply} alias Phoenix.Channel.Server defmodule NoopSerializer do @behaviour Phoenix.Socket.Serializer @moduledoc false def fastlane!(%Broadcast{} = msg) do %Message{ topic: msg.topic, event: msg.event, payload: msg.payload } end def encode!(%Reply{} = reply), do: reply def encode!(%Message{} = msg), do: msg def decode!(message, _opts), do: message end @doc false defmacro __using__(_) do IO.warn """ Using Phoenix.ChannelTest is deprecated, instead of: use Phoenix.ChannelTest do: import Phoenix.ChannelTest """, Macro.Env.stacktrace(__CALLER__) quote do import Phoenix.ChannelTest end end @doc """ Builds a socket for the given `socket_module`. The socket is then used to subscribe and join channels. Use this function when you want to create a blank socket to pass to functions like `UserSocket.connect/3`. Otherwise, use `socket/4` if you want to build a socket with existing id and assigns. ## Examples socket(MyApp.UserSocket) """ defmacro socket(socket_module) do socket(socket_module, nil, [], [], __CALLER__) end @doc """ Builds a socket for the given `socket_module` with given id and assigns. ## Examples socket(MyApp.UserSocket, "user_id", %{some: :assign}) If you need to access the socket in another process than the test process, you can give the `pid` of the test process in the 4th argument. ## Examples test "connect in a task" do pid = self() task = Task.async(fn -> socket = socket(MyApp.UserSocket, "user_id", %{some: :assign}, test_process: pid) broadcast_from!(socket, "default", %{"foo" => "bar"}) assert_push "default", %{"foo" => "bar"} end) Task.await(task) end """ defmacro socket(socket_module, socket_id, socket_assigns, options \\ []) do socket(socket_module, socket_id, socket_assigns, options, __CALLER__) end defp socket(module, id, assigns, options, caller) do if endpoint = Module.get_attribute(caller.module, :endpoint) do quote do unquote(__MODULE__).__socket__( unquote(module), unquote(id), unquote(assigns), unquote(endpoint), unquote(options) ) end else raise "module attribute @endpoint not set for socket/2" end end @doc false def __socket__(socket, id, assigns, endpoint, options) do %Socket{ assigns: Enum.into(assigns, %{}), endpoint: endpoint, handler: socket || first_socket!(endpoint), id: id, pubsub_server: endpoint.config(:pubsub_server), serializer: NoopSerializer, transport: {__MODULE__, fetch_test_supervisor!(options)}, transport_pid: self() } end defp first_socket!(endpoint) do case endpoint.__sockets__ do [] -> raise ArgumentError, "#{inspect endpoint} has no socket declaration" [{_, socket, _} | _] -> socket end end defp fetch_test_supervisor!(options) do case ExUnit.OnExitHandler.get_supervisor(Keyword.get(options, :test_process, self())) do {:ok, nil} -> opts = [strategy: :one_for_one, max_restarts: 1_000_000, max_seconds: 1] {:ok, sup} = Supervisor.start_link([], opts) ExUnit.OnExitHandler.put_supervisor(self(), sup) sup {:ok, sup} -> sup :error -> raise ArgumentError, "socket/1-3 can only be invoked from the test process" end end @doc false @deprecated "Phoenix.ChannelTest.socket/0 is deprecated, please call socket/1 instead" defmacro socket() do socket(nil, nil, [], [], __CALLER__) end @doc false @deprecated "Phoenix.ChannelTest.socket/2 is deprecated, please call socket/4 instead" defmacro socket(id, assigns) do socket(nil, id, assigns, [], __CALLER__) end @doc """ Initiates a transport connection for the socket handler. Useful for testing UserSocket authentication. Returns the result of the handler's `connect/3` callback. """ defmacro connect(handler, params, options \\ quote(do: [])) do if endpoint = Module.get_attribute(__CALLER__.module, :endpoint) do quote do unquote(__MODULE__).__connect__( unquote(endpoint), unquote(handler), unquote(params), unquote(options) ) end else raise "module attribute @endpoint not set for socket/2" end end @doc false def __connect__(endpoint, handler, params, options) do {connect_info, options} = if is_map(options) do IO.warn( "Passing \"connect_info\" directly to connect/3 is deprecated, please pass \"connect_info: ...\" as an option instead" ) {options, []} else Keyword.pop(options, :connect_info, %{}) end map = %{ endpoint: endpoint, transport: {__MODULE__, fetch_test_supervisor!(options)}, options: [serializer: [{NoopSerializer, "~> 1.0.0"}]], params: __stringify__(params), connect_info: connect_info } with {:ok, state} <- handler.connect(map), {:ok, {_, socket}} = handler.init(state), do: {:ok, socket} end @doc "See `subscribe_and_join!/4`." def subscribe_and_join!(%Socket{} = socket, topic) when is_binary(topic) do subscribe_and_join!(socket, nil, topic, %{}) end @doc "See `subscribe_and_join!/4`." def subscribe_and_join!(%Socket{} = socket, topic, payload) when is_binary(topic) and is_map(payload) do subscribe_and_join!(socket, nil, topic, payload) end @doc """ Same as `subscribe_and_join/4`, but returns either the socket or throws an error. This is helpful when you are not testing joining the channel and just need the socket. """ def subscribe_and_join!(%Socket{} = socket, channel, topic, payload \\ %{}) when is_atom(channel) and is_binary(topic) and is_map(payload) do case subscribe_and_join(socket, channel, topic, payload) do {:ok, _, socket} -> socket {:error, error} -> raise "could not join channel, got error: #{inspect(error)}" end end @doc "See `subscribe_and_join/4`." def subscribe_and_join(%Socket{} = socket, topic) when is_binary(topic) do subscribe_and_join(socket, nil, topic, %{}) end @doc "See `subscribe_and_join/4`." def subscribe_and_join(%Socket{} = socket, topic, payload) when is_binary(topic) and is_map(payload) do subscribe_and_join(socket, nil, topic, payload) end @doc """ Subscribes to the given topic and joins the channel under the given topic and payload. By subscribing to the topic, we can use `assert_broadcast/3` to verify a message has been sent through the pubsub layer. By joining the channel, we can interact with it directly. The given channel is joined in a separate process which is linked to the test process. If no channel module is provided, the socket's handler is used to lookup the matching channel for the given topic. It returns `{:ok, reply, socket}` or `{:error, reply}`. """ def subscribe_and_join(%Socket{} = socket, channel, topic, payload \\ %{}) when is_atom(channel) and is_binary(topic) and is_map(payload) do socket.endpoint.subscribe(topic) join(socket, channel, topic, payload) end @doc "See `join/4`." def join(%Socket{} = socket, topic) when is_binary(topic) do join(socket, nil, topic, %{}) end @doc "See `join/4`." def join(%Socket{} = socket, topic, payload) when is_binary(topic) and is_map(payload) do join(socket, nil, topic, payload) end @doc """ Joins the channel under the given topic and payload. The given channel is joined in a separate process which is linked to the test process. It returns `{:ok, reply, socket}` or `{:error, reply}`. """ def join(%Socket{} = socket, channel, topic, payload \\ %{}) when is_atom(channel) and is_binary(topic) and is_map(payload) do message = %Message{ event: "phx_join", payload: __stringify__(payload), topic: topic, ref: System.unique_integer([:positive]) } {channel, opts} = if channel do {channel, []} else match_topic_to_channel!(socket, topic) end %Socket{transport: {__MODULE__, sup}} = socket starter = fn _, _, spec -> Supervisor.start_child(sup, %{spec | id: make_ref()}) end case Server.join(socket, channel, message, [starter: starter] ++ opts) do {:ok, reply, pid} -> Process.link(pid) {:ok, reply, Server.socket(pid)} {:error, _} = error -> error end end @doc """ Pushes a message into the channel. The triggers the `handle_in/3` callback in the channel. ## Examples iex> push(socket, "new_message", %{id: 1, content: "hello"}) reference """ @spec push(Socket.t, String.t, map()) :: reference() def push(%Socket{} = socket, event, payload \\ %{}) do ref = make_ref() send(socket.channel_pid, %Message{event: event, topic: socket.topic, ref: ref, payload: __stringify__(payload)}) ref end @doc """ Emulates the client leaving the channel. By default this will crash the test process. Run `Process.unlink(socket.channel_pid)` before this to prevent this from happening. See [Leave and close](#module-leave-and-close). """ @spec leave(Socket.t) :: reference() def leave(%Socket{} = socket) do push(socket, "phx_leave", %{}) end @doc """ Emulates the client closing the socket. By default this will crash the test process. Run `Process.unlink(socket.channel_pid)` before this to prevent this from happening. See [Leave and close](#module-leave-and-close). Closing socket is synchronous and has a default timeout of 5000 milliseconds. """ def close(%Socket{} = socket, timeout \\ 5000) do Server.close(socket.channel_pid, timeout) end @doc """ Broadcast event from pid to all subscribers of the socket topic. The test process will not receive the published message. This triggers the `handle_out/3` callback in the channel. ## Examples iex> broadcast_from(socket, "new_message", %{id: 1, content: "hello"}) :ok """ def broadcast_from(%Socket{} = socket, event, message) do %{pubsub_server: pubsub_server, topic: topic, transport_pid: transport_pid} = socket Server.broadcast_from pubsub_server, transport_pid, topic, event, message end @doc """ Same as `broadcast_from/3`, but raises if broadcast fails. """ def broadcast_from!(%Socket{} = socket, event, message) do %{pubsub_server: pubsub_server, topic: topic, transport_pid: transport_pid} = socket Server.broadcast_from! pubsub_server, transport_pid, topic, event, message end @doc """ Asserts the channel has pushed a message back to the client with the given event and payload within `timeout`. Notice event and payload are patterns. This means one can write: assert_push "some_event", %{"data" => _} In the assertion above, we don't particularly care about the data being sent, as long as something was sent. The timeout is in milliseconds and defaults to the `:assert_receive_timeout` set on the `:ex_unit` application (which defaults to 100ms). **NOTE:** Because event and payload are patterns, they will be matched. This means that if you wish to assert that the received payload is equivalent to an existing variable, you need to pin the variable in the assertion expression. Good: expected_payload = %{foo: "bar"} assert_push "some_event", ^expected_payload Bad: expected_payload = %{foo: "bar"} assert_push "some_event", expected_payload # The code above does not assert the payload matches the described map. Guards can also be given to the payload pattern: assert_push "some_event", %{"counter" => c} when c > 0 """ defmacro assert_push(event, payload, timeout \\ Application.fetch_env!(:ex_unit, :assert_receive_timeout)) do pattern = extract_pattern_and_apply_guard(event, payload, Phoenix.Socket.Message) quote do assert_receive unquote(pattern), unquote(timeout) end end @doc """ Asserts the channel has not pushed a message to the client matching the given event and payload within `timeout`. Like `assert_push`, the event and payload are patterns. The timeout is in milliseconds and defaults to the `:refute_receive_timeout` set on the `:ex_unit` application (which defaults to 100ms). Keep in mind this macro will block the test by the timeout value, so use it only when necessary as overuse will certainly slow down your test suite. """ defmacro refute_push(event, payload, timeout \\ Application.fetch_env!(:ex_unit, :refute_receive_timeout)) do quote do refute_receive %Phoenix.Socket.Message{ event: unquote(event), payload: unquote(payload)}, unquote(timeout) end end @doc """ Asserts the channel has replied to the given message within `timeout`. Notice status and payload are patterns. This means one can write: ref = push(channel, "some_event") assert_reply ref, :ok, %{"data" => _} In the assertion above, we don't particularly care about the data being sent, as long as something was replied. The timeout is in milliseconds and defaults to the `:assert_receive_timeout` set on the `:ex_unit` application (which defaults to 100ms). Guards can also be given to the payload pattern: ref = push(channel, "some_event") assert_reply ref, :ok, %{"counter" => c} when c > 0 """ defmacro assert_reply(ref, status, payload \\ Macro.escape(%{}), timeout \\ Application.fetch_env!(:ex_unit, :assert_receive_timeout)) do {payload, guard} = extract_guard(payload) pattern = quote do %Phoenix.Socket.Reply{ ref: ^ref, status: unquote(status), payload: unquote(payload)} end struct_pattern = apply_guard(pattern, guard) quote do ref = unquote(ref) assert_receive unquote(struct_pattern), unquote(timeout) end end @doc """ Asserts the channel has not replied with a matching payload within `timeout`. Like `assert_reply`, the event and payload are patterns. The timeout is in milliseconds and defaults to the `:refute_receive_timeout` set on the `:ex_unit` application (which defaults to 100ms). Keep in mind this macro will block the test by the timeout value, so use it only when necessary as overuse will certainly slow down your test suite. """ defmacro refute_reply(ref, status, payload \\ Macro.escape(%{}), timeout \\ Application.fetch_env!(:ex_unit, :refute_receive_timeout)) do quote do ref = unquote(ref) refute_receive %Phoenix.Socket.Reply{ ref: ^ref, status: unquote(status), payload: unquote(payload)}, unquote(timeout) end end @doc """ Asserts the channel has broadcast a message within `timeout`. Before asserting anything was broadcast, we must first subscribe to the topic of the channel in the test process: @endpoint.subscribe("foo:ok") Now we can match on event and payload as patterns: assert_broadcast "some_event", %{"data" => _} In the assertion above, we don't particularly care about the data being sent, as long as something was sent. The timeout is in milliseconds and defaults to the `:assert_receive_timeout` set on the `:ex_unit` application (which defaults to 100ms). Guards can also be given to the payload pattern: assert_broadcast "some_event", %{"counter" => c} when c > 0 """ defmacro assert_broadcast(event, payload, timeout \\ Application.fetch_env!(:ex_unit, :assert_receive_timeout)) do pattern = extract_pattern_and_apply_guard(event, payload, Phoenix.Socket.Broadcast) quote do assert_receive unquote(pattern), unquote(timeout) end end @doc """ Asserts the channel has not broadcast a message within `timeout`. Like `assert_broadcast`, the event and payload are patterns. The timeout is in milliseconds and defaults to the `:refute_receive_timeout` set on the `:ex_unit` application (which defaults to 100ms). Keep in mind this macro will block the test by the timeout value, so use it only when necessary as overuse will certainly slow down your test suite. """ defmacro refute_broadcast(event, payload, timeout \\ Application.fetch_env!(:ex_unit, :refute_receive_timeout)) do quote do refute_receive %Phoenix.Socket.Broadcast{event: unquote(event), payload: unquote(payload)}, unquote(timeout) end end defp match_topic_to_channel!(socket, topic) do unless socket.handler do raise """ no socket handler found to lookup channel for topic #{inspect topic}. Use connect/3 when calling subscribe_and_join/* (or subscribe_and_join!/*) without a channel, for example: {:ok, socket} = connect(UserSocket, %{}, %{}) socket = subscribe_and_join!(socket, "foo:bar", %{}) """ end case socket.handler.__channel__(topic) do {channel, opts} when is_atom(channel) -> {channel, opts} _ -> raise "no channel found for topic #{inspect topic} in #{inspect socket.handler}" end end defp extract_guard({:when, _, [payload, guard]}), do: {payload, guard} defp extract_guard(payload), do: {payload, nil} defp apply_guard(pattern, nil), do: pattern defp apply_guard(pattern, guard), do: {:when, [], [pattern, guard]} defp extract_pattern_and_apply_guard(event, payload, struct_module) do {payload, guard} = extract_guard(payload) pattern_struct = quote do %{__struct__: unquote(struct_module), event: unquote(event), payload: unquote(payload)} end apply_guard(pattern_struct, guard) end @doc false def __stringify__(%{__struct__: _} = struct), do: struct def __stringify__(%{} = params), do: Enum.into(params, %{}, &stringify_kv/1) def __stringify__(params) when is_list(params), do: Enum.map(params, &__stringify__/1) def __stringify__(other), do: other defp stringify_kv({k, v}), do: {to_string(k), __stringify__(v)} end ================================================ FILE: lib/phoenix/test/conn_test.ex ================================================ defmodule Phoenix.ConnTest do @moduledoc """ Conveniences for testing Phoenix endpoints and connection related helpers. You likely want to use this module or make it part of your `ExUnit.CaseTemplate`. Once used, this module automatically imports all functions defined here as well as the functions in `Plug.Conn`. ## Endpoint testing `Phoenix.ConnTest` typically works against endpoints. That's the preferred way to test anything that your router dispatches to: @endpoint MyAppWeb.Endpoint test "says welcome on the home page" do conn = get(build_conn(), "/") assert conn.resp_body =~ "Welcome!" end test "logs in" do conn = post(build_conn(), "/login", [username: "john", password: "doe"]) assert conn.resp_body =~ "Logged in!" end The `@endpoint` module attribute contains the endpoint under testing, most commonly your application endpoint itself. If you are using the MyApp.ConnCase generated by Phoenix, it is automatically set for you. As in your router and controllers, the connection is the main abstraction in testing. `build_conn()` returns a new connection and functions in this module can be used to manipulate the connection before dispatching to the endpoint. For example, one could set the accepts header for json requests as follows: build_conn() |> put_req_header("accept", "application/json") |> get("/") You can also create your own helpers, such as `json_conn()` that uses `build_conn/0` and `put_req_header/3`, so you avoid repeating the connection setup throughout your tests. ## Controller testing The functions in this module can also be used for controller testing. While endpoint testing is preferred over controller testing, especially since the controller in Phoenix plays an integration role between your domain and your views, unit testing controllers may be helpful in some situations. For such cases, you need to set the `@endpoint` attribute to your controller and pass an atom representing the action to dispatch: @endpoint MyAppWeb.HomeController test "says welcome on the home page" do conn = get(build_conn(), :index) assert conn.resp_body =~ "Welcome!" end Keep in mind that, once the `@endpoint` variable is set, all tests after setting it will be affected. ## Views testing Under other circumstances, you may be testing a view or another layer that requires a connection for processing. For such cases, a connection can be created using the `build_conn/3` helper: MyApp.UserView.render("hello.html", conn: build_conn(:get, "/")) While `build_conn/0` returns a connection with no request information to it, `build_conn/3` returns a connection with the given request information already filled in. ## Recycling Browsers implement a storage by using cookies. When a cookie is set in the response, the browser stores it and sends it in the next request. To emulate this behaviour, this module provides the idea of recycling. The `recycle/1` function receives a connection and returns a new connection, similar to the one returned by `build_conn/0` with all the response cookies from the previous connection defined as request headers. This is useful when testing multiple routes that require cookies or session to work. Keep in mind Phoenix will automatically recycle the connection between dispatches. This usually works out well most times, but it may discard information if you are modifying the connection before the next dispatch: # No recycling as the connection is fresh conn = get(build_conn(), "/") # The connection is recycled, creating a new one behind the scenes conn = post(conn, "/login") # We can also recycle manually in case we want custom headers conn = conn |> recycle() |> put_req_header("x-special", "nice") # No recycling as we did it explicitly conn = delete(conn, "/logout") Recycling also recycles the "accept" and "authorization" headers, as well as peer data information. """ @doc false defmacro __using__(_) do IO.warn """ Using Phoenix.ConnTest is deprecated, instead of: use Phoenix.ConnTest do: import Plug.Conn import Phoenix.ConnTest """, Macro.Env.stacktrace(__CALLER__) quote do import Plug.Conn import Phoenix.ConnTest end end alias Plug.Conn import ExUnit.Assertions, only: [flunk: 1] @doc """ Creates a connection to be used in upcoming requests. """ @spec build_conn() :: Conn.t def build_conn() do build_conn(:get, "/", nil) end @doc """ Creates a connection to be used in upcoming requests with a preset method, path and body. This is useful when a specific connection is required for testing a plug or a particular function. """ @spec build_conn(atom | binary, binary, binary | list | map | nil) :: Conn.t def build_conn(method, path, params_or_body \\ nil) do Plug.Adapters.Test.Conn.conn(%Conn{}, method, path, params_or_body) |> Conn.put_private(:plug_skip_csrf_protection, true) |> Conn.put_private(:phoenix_recycled, true) end @http_methods [:get, :post, :put, :patch, :delete, :options, :connect, :trace, :head] for method <- @http_methods do @doc """ Dispatches to the current endpoint. See `dispatch/5` for more information. """ defmacro unquote(method)(conn, path_or_action, params_or_body \\ nil) do method = unquote(method) quote do Phoenix.ConnTest.dispatch(unquote(conn), @endpoint, unquote(method), unquote(path_or_action), unquote(params_or_body)) end end end @doc """ Dispatches the connection to the given endpoint. When invoked via `get/3`, `post/3` and friends, the endpoint is automatically retrieved from the `@endpoint` module attribute, otherwise it must be given as an argument. The connection will be configured with the given `method`, `path_or_action` and `params_or_body`. If `path_or_action` is a string, it is considered to be the request path and stored as so in the connection. If an atom, it is assumed to be an action and the connection is dispatched to the given action. ## Parameters and body This function, as well as `get/3`, `post/3` and friends, accepts the request body or parameters as last argument: get(build_conn(), "/", some: "param") get(build_conn(), "/", "some=param&url=encoded") The allowed values are: * `nil` - meaning there is no body * a binary - containing a request body. For such cases, `:headers` must be given as option with a content-type * a map or list - containing the parameters which will automatically set the content-type to multipart. The map or list may contain other lists or maps and all entries will be normalized to string keys * a struct - unlike other maps, a struct will be passed through as-is without normalizing its entries """ def dispatch(conn, endpoint, method, path_or_action, params_or_body \\ nil) def dispatch(%Plug.Conn{} = conn, endpoint, method, path_or_action, params_or_body) do if is_nil(endpoint) do raise "no @endpoint set in test case" end if is_binary(params_or_body) and is_nil(List.keyfind(conn.req_headers, "content-type", 0)) do raise ArgumentError, "a content-type header is required when setting " <> "a binary body in a test connection" end conn |> ensure_recycled() |> dispatch_endpoint(endpoint, method, path_or_action, params_or_body) |> Conn.put_private(:phoenix_recycled, false) |> from_set_to_sent() end def dispatch(conn, _endpoint, method, _path_or_action, _params_or_body) do raise ArgumentError, "expected first argument to #{method} to be a " <> "%Plug.Conn{}, got #{inspect conn}" end defp dispatch_endpoint(conn, endpoint, method, path, params_or_body) when is_binary(path) do conn |> Plug.Adapters.Test.Conn.conn(method, path, params_or_body) |> endpoint.call(endpoint.init([])) end defp dispatch_endpoint(conn, endpoint, method, action, params_or_body) when is_atom(action) do conn |> Plug.Adapters.Test.Conn.conn(method, "/", params_or_body) |> endpoint.call(endpoint.init(action)) end defp from_set_to_sent(%Conn{state: :set} = conn), do: Conn.send_resp(conn) defp from_set_to_sent(conn), do: conn @doc """ Inits a session used exclusively for testing. """ @spec init_test_session(Conn.t, map | keyword) :: Conn.t defdelegate init_test_session(conn, session), to: Plug.Test @doc """ Puts a request cookie. """ @spec put_req_cookie(Conn.t, binary, binary) :: Conn.t defdelegate put_req_cookie(conn, key, value), to: Plug.Test @doc """ Deletes a request cookie. """ @spec delete_req_cookie(Conn.t, binary) :: Conn.t defdelegate delete_req_cookie(conn, key), to: Plug.Test @doc """ Fetches the flash storage. """ @spec fetch_flash(Conn.t) :: Conn.t defdelegate fetch_flash(conn), to: Phoenix.Controller @doc """ Gets the whole flash storage. """ @spec get_flash(Conn.t) :: map @deprecated "get_flash/1 is deprecated. Use conn.assigns.flash instead" def get_flash(conn), do: conn.assigns.flash @doc """ Gets the given key from the flash storage. """ @spec get_flash(Conn.t, term) :: term @deprecated "get_flash/2 is deprecated. Use Phoenix.Flash.get/2 instead" def get_flash(conn, key) do Phoenix.Flash.get(conn.assigns.flash, key) end @doc """ Puts the given value under key in the flash storage. """ @spec put_flash(Conn.t, term, term) :: Conn.t defdelegate put_flash(conn, key, value), to: Phoenix.Controller @doc """ Clears up the flash storage. """ @spec clear_flash(Conn.t) :: Conn.t defdelegate clear_flash(conn), to: Phoenix.Controller @doc """ Returns the content type as long as it matches the given format. ## Examples # Assert we have an html response with utf-8 charset assert response_content_type(conn, :html) =~ "charset=utf-8" """ @spec response_content_type(Conn.t, atom) :: String.t def response_content_type(conn, format) when is_atom(format) do case Conn.get_resp_header(conn, "content-type") do [] -> raise "no content-type was set, expected a #{format} response" [h] -> if response_content_type?(h, format) do h else raise "expected content-type for #{format}, got: #{inspect h}" end [_|_] -> raise "more than one content-type was set, expected a #{format} response" end end defp response_content_type?(header, format) do case parse_content_type(header) do {part, subpart} -> format = Atom.to_string(format) format in MIME.extensions(part <> "/" <> subpart) or format == subpart or String.ends_with?(subpart, "+" <> format) _ -> false end end defp parse_content_type(header) do case Plug.Conn.Utils.content_type(header) do {:ok, part, subpart, _params} -> {part, subpart} _ -> false end end @doc """ Asserts the given status code and returns the response body if one was set or sent. ## Examples conn = get(build_conn(), "/") assert response(conn, 200) =~ "hello world" """ @spec response(Conn.t, status :: integer | atom) :: binary def response(%Conn{state: :unset}, _status) do raise """ expected connection to have a response but no response was set/sent. Please verify that you assign to "conn" after a request: conn = get(conn, "/") assert html_response(conn) =~ "Hello" """ end def response(%Conn{status: status, resp_body: body}, given) do given = Plug.Conn.Status.code(given) if given == status do body else raise "expected response with status #{given}, got: #{status}, with body:\n#{inspect(body)}" end end @doc """ Asserts the given status code, that we have an html response and returns the response body if one was set or sent. ## Examples assert html_response(conn, 200) =~ "" """ @spec html_response(Conn.t, status :: integer | atom) :: String.t def html_response(conn, status) do body = response(conn, status) _ = response_content_type(conn, :html) body end @doc """ Asserts the given status code, that we have a text response and returns the response body if one was set or sent. ## Examples assert text_response(conn, 200) =~ "hello" """ @spec text_response(Conn.t, status :: integer | atom) :: String.t def text_response(conn, status) do body = response(conn, status) _ = response_content_type(conn, :text) body end @doc """ Asserts the given status code, that we have a json response and returns the decoded JSON response if one was set or sent. ## Examples body = json_response(conn, 200) assert "can't be blank" in body["errors"] """ @spec json_response(Conn.t, status :: integer | atom) :: term def json_response(conn, status) do body = response(conn, status) _ = response_content_type(conn, :json) Phoenix.json_library().decode!(body) end @doc """ Returns the location header from the given redirect response. Raises if the response does not match the redirect status code (defaults to 302). ## Examples assert redirected_to(conn) =~ "/foo/bar" assert redirected_to(conn, 301) =~ "/foo/bar" assert redirected_to(conn, :moved_permanently) =~ "/foo/bar" """ @spec redirected_to(Conn.t, status :: non_neg_integer) :: String.t def redirected_to(conn, status \\ 302) def redirected_to(%Conn{state: :unset}, _status) do raise "expected connection to have redirected but no response was set/sent" end def redirected_to(conn, status) when is_atom(status) do redirected_to(conn, Plug.Conn.Status.code(status)) end def redirected_to(%Conn{status: status} = conn, status) do location = Conn.get_resp_header(conn, "location") |> List.first location || raise "no location header was set on redirected_to" end def redirected_to(conn, status) do raise "expected redirection with status #{status}, got: #{conn.status}" end @doc """ Recycles the connection. Recycling receives a connection and returns a new connection, containing cookies and relevant information from the given one. This emulates behaviour performed by browsers where cookies returned in the response are available in following requests. By default, only the headers "accept", "accept-language", and "authorization" are recycled. However, a custom set of headers can be specified by passing a list of strings representing its names as the second argument of the function. Note `recycle/1` is automatically invoked when dispatching to the endpoint, unless the connection has already been recycled. """ @spec recycle(Conn.t, [String.t]) :: Conn.t def recycle(conn, headers \\ ~w(accept accept-language authorization)) do build_conn() |> Map.put(:host, conn.host) |> Map.put(:remote_ip, conn.remote_ip) |> Plug.Test.recycle_cookies(conn) |> Plug.Test.put_peer_data(Plug.Conn.get_peer_data(conn)) |> copy_headers(conn.req_headers, headers) end defp copy_headers(conn, headers, copy) do headers = for {k, v} <- headers, k in copy, do: {k, v} %{conn | req_headers: headers ++ conn.req_headers} end @doc """ Ensures the connection is recycled if it wasn't already. See `recycle/1` for more information. """ @spec ensure_recycled(Conn.t) :: Conn.t def ensure_recycled(conn) do if conn.private[:phoenix_recycled] do conn else recycle(conn) end end @doc """ Calls the Endpoint and Router pipelines. Useful for unit testing Plugs where Endpoint and/or router pipeline plugs are required for proper setup. Note the use of `get("/")` following `bypass_through` in the examples below. To execute the plug pipelines, you must issue a request against the router. Most often, you can simply send a GET request against the root path, but you may also specify a different method or path which your pipelines may operate against. ## Examples For example, imagine you are testing an authentication plug in isolation, but you need to invoke the Endpoint plugs and router pipelines to set up session and flash related dependencies. One option is to invoke an existing route that uses the proper pipelines. You can do so by passing the connection and the router name to `bypass_through`: conn = conn |> bypass_through(MyAppWeb.Router) |> get("/some_url") |> MyApp.RequireAuthentication.call([]) assert conn.halted You can also specify which pipelines you want to run: conn = conn |> bypass_through(MyAppWeb.Router, [:browser]) |> get("/") |> MyApp.RequireAuthentication.call([]) assert conn.halted Alternatively, you could only invoke the Endpoint's plugs: conn = conn |> bypass_through() |> get("/") |> MyApp.RequireAuthentication.call([]) assert conn.halted """ @spec bypass_through(Conn.t) :: Conn.t def bypass_through(conn) do Plug.Conn.put_private(conn, :phoenix_bypass, :all) end @doc """ Calls the Endpoint and Router pipelines for the current route. See `bypass_through/1`. """ @spec bypass_through(Conn.t, module) :: Conn.t def bypass_through(conn, router) do Plug.Conn.put_private(conn, :phoenix_bypass, {router, :current}) end @doc """ Calls the Endpoint and the given Router pipelines. See `bypass_through/1`. """ @spec bypass_through(Conn.t, module, atom | list) :: Conn.t def bypass_through(conn, router, pipelines) do Plug.Conn.put_private(conn, :phoenix_bypass, {router, List.wrap(pipelines)}) end @doc """ Returns the matched params from the URL the connection was redirected to. Uses the provided `%Plug.Conn{}`s router matched in the previous request. Raises if the response's location header is not set or if the response does not match the redirect status code (defaults to 302). ## Examples assert redirected_to(conn) =~ "/posts/123" assert %{id: "123"} = redirected_params(conn) assert %{id: "123"} = redirected_params(conn, 303) """ @spec redirected_params(Conn.t, status :: non_neg_integer) :: map def redirected_params(%Plug.Conn{} = conn, status \\ 302) do router = Phoenix.Controller.router_module(conn) %URI{path: path, host: host} = conn |> redirected_to(status) |> URI.parse() path = remove_script_name(conn, router, path) case Phoenix.Router.route_info(router, "GET", path, host || conn.host) do :error -> raise Phoenix.Router.NoRouteError, conn: conn, router: router %{path_params: path_params} -> Enum.into(path_params, %{}, fn {key, val} -> {String.to_atom(key), val} end) end end defp remove_script_name(conn, router, path) do case conn.private[router] do [_ | _] = list -> script_name = "/" <> Enum.join(list, ",") String.replace_leading(path, script_name, "") _ -> path end end @doc """ Returns the matched params of the URL for the `%Plug.Conn{}`'s router. Useful for extracting path params out of returned URLs, such as those returned by `Phoenix.LiveViewTest`'s redirected results. ## Examples assert {:error, {:redirect, %{to: "/posts/123" = to}}} = live(conn, "/path") assert %{id: "123"} = path_params(conn, to) """ @spec path_params(Conn.t, String.t) :: map def path_params(%Plug.Conn{} = conn, to) when is_binary(to) do router = Phoenix.Controller.router_module(conn) case Phoenix.Router.route_info(router, "GET", to, conn.host) do %{path_params: path_params} -> Enum.into(path_params, %{}, fn {key, val} -> {String.to_atom(key), val} end) :error -> raise Phoenix.Router.NoRouteError, conn: conn, router: router end end @doc """ Asserts an error was wrapped and sent with the given status. Useful for testing actions that you expect raise an error and have the response wrapped in an HTTP status, with content usually rendered by your MyAppWeb.ErrorHTML view. The function accepts a status either as an integer HTTP status or atom, such as `500` or `:internal_server_error`. The list of allowed atoms is available in `Plug.Conn.Status`. If an error is raised, a 3-tuple of the wrapped response is returned matching the status, headers, and body of the response: {500, [{"content-type", "text/html"} | _], "Internal Server Error"} ## Examples assert_error_sent :internal_server_error, fn -> get(build_conn(), "/broken/route") end response = assert_error_sent 500, fn -> get(build_conn(), "/broken/route") end assert {500, [_h | _t], "Internal Server Error"} = response This can also be used to test a route resulted in an error that was translated to a specific response by the `Plug.Status` protocol, such as `Ecto.NoResultsError`: assert_error_sent :not_found, fn -> get(build_conn(), "/something-that-raises-no-results-error") end *Note*: for routes that don't raise an error, but instead return a status, you should test the response directly: conn = get(build_conn(), "/users/not-found") assert response(conn, 404) """ @spec assert_error_sent(integer | atom, function) :: {integer, list, term} def assert_error_sent(status_int_or_atom, func) do expected_status = Plug.Conn.Status.code(status_int_or_atom) discard_previously_sent() result = func |> wrap_request() |> receive_response(expected_status) discard_previously_sent() result end defp receive_response({:ok, conn}, expected_status) do if conn.state == :sent do flunk "expected error to be sent as #{expected_status} status, but response sent #{conn.status} without error" else flunk "expected error to be sent as #{expected_status} status, but no error happened" end end defp receive_response({:error, {_kind, exception, stack}}, expected_status) do receive do {ref, {^expected_status, headers, body}} when is_reference(ref) -> {expected_status, headers, body} {ref, {sent_status, _headers, _body}} when is_reference(ref) -> reraise ExUnit.AssertionError.exception(""" expected error to be sent as #{expected_status} status, but got #{sent_status} from: #{Exception.format_banner(:error, exception)} """), stack after 0 -> reraise ExUnit.AssertionError.exception(""" expected error to be sent as #{expected_status} status, but got an error with no response from: #{Exception.format_banner(:error, exception)} """), stack end end defp discard_previously_sent() do receive do {ref, {_, _, _}} when is_reference(ref) -> discard_previously_sent() {:plug_conn, :sent} -> discard_previously_sent() after 0 -> :ok end end defp wrap_request(func) do try do {:ok, func.()} catch kind, error -> {:error, {kind, error, __STACKTRACE__}} end end end ================================================ FILE: lib/phoenix/token.ex ================================================ defmodule Phoenix.Token do @moduledoc """ Conveniences to sign/encrypt data inside tokens for use in Channels, API authentication, and more. The data stored in the token is signed to prevent tampering, and is optionally encrypted. This means that, so long as the key (see below) remains secret, you can be assured that the data stored in the token has not been tampered with by a third party. However, unless the token is encrypted, it is not safe to use this token to store private information, such as a user's sensitive identification data, as it can be trivially decoded. If the token is encrypted, its contents will be kept secret from the client, but it is still a best practice to encode as little secret information as possible, to minimize the impact of key leakage. ## Example When generating a unique token for use in an API or Channel it is advised to use a unique identifier for the user, typically the id from a database. For example: iex> user_id = 1 iex> token = Phoenix.Token.sign(MyAppWeb.Endpoint, "user auth", user_id) iex> Phoenix.Token.verify(MyAppWeb.Endpoint, "user auth", token, max_age: 86400) {:ok, 1} In that example we have a user's id, we generate a token and verify it using the secret key base configured in the given `endpoint`. We guarantee the token will only be valid for one day by setting a max age (recommended). The first argument to `sign/4`, `verify/4`, `encrypt/4`, and `decrypt/4` can be one of: * the module name of a Phoenix endpoint (shown above) - where the secret key base is extracted from the endpoint * `Plug.Conn` - where the secret key base is extracted from the endpoint stored in the connection * `Phoenix.Socket` or `Phoenix.LiveView.Socket` - where the secret key base is extracted from the endpoint stored in the socket * a string, representing the secret key base itself. A key base with at least 20 randomly generated characters should be used to provide adequate entropy The second argument is a [cryptographic salt](https://en.wikipedia.org/wiki/Salt_(cryptography)) which must be the same in both calls to `sign/4` and `verify/4`, or both calls to `encrypt/4` and `decrypt/4`. For instance, it may be called "user auth" and treated as namespace when generating a token that will be used to authenticate users on channels or on your APIs. The third argument can be any term (string, int, list, etc.) that you wish to codify into the token. Upon valid verification, this same term will be extracted from the token. ## Usage Once a token is signed, we can send it to the client in multiple ways. One is via the meta tag: ```heex ``` Or an endpoint that returns it: def create(conn, params) do user = User.create(params) render(conn, "user.json", %{token: Phoenix.Token.sign(conn, "user auth", user.id), user: user}) end Once the token is sent, the client may now send it back to the server as an authentication mechanism. For example, we can use it to authenticate a user on a Phoenix channel: defmodule MyApp.UserSocket do use Phoenix.Socket def connect(%{"token" => token}, socket, _connect_info) do case Phoenix.Token.verify(socket, "user auth", token, max_age: 86400) do {:ok, user_id} -> socket = assign(socket, :user, Repo.get!(User, user_id)) {:ok, socket} {:error, _} -> :error end end def connect(_params, _socket, _connect_info), do: :error end In this example, the phoenix.js client will send the token in the `connect` command which is then validated by the server. `Phoenix.Token` can also be used for validating APIs, handling password resets, e-mail confirmation and more. """ @type context :: Plug.Conn.t() | %{required(:endpoint) => atom, optional(atom()) => any()} | atom | binary @type shared_opt :: {:key_iterations, pos_integer} | {:key_length, pos_integer} | {:key_digest, :sha256 | :sha384 | :sha512} @type max_age_opt :: {:max_age, pos_integer | :infinity} @type signed_at_opt :: {:signed_at, pos_integer} @doc """ Encodes and signs data into a token you can send to clients. ## Options * `:key_iterations` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 1000 * `:key_length` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 32 * `:key_digest` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to `:sha256` * `:signed_at` - set the timestamp of the token in *seconds*. If no value is provided, it will be set to the current time in milliseconds. * `:max_age` - the default maximum age in **seconds** of the token. Defaults to 86400 seconds (1 day) and it may be overridden on `verify/4`. """ @spec sign(context, binary, term, [shared_opt | max_age_opt | signed_at_opt]) :: binary def sign(context, salt, data, opts \\ []) when is_binary(salt) do context |> get_key_base() |> Plug.Crypto.sign(salt, data, opts) end @doc """ Encodes, encrypts, and signs data into a token you can send to clients. Its usage is identical to that of `sign/4`, but the data is extracted using `decrypt/4`, rather than `verify/4`. ## Options * `:key_iterations` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 1000 * `:key_length` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 32 * `:key_digest` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to `:sha256` * `:signed_at` - set the timestamp of the token in **seconds**. If no value is provided, it will be set to the current time in milliseconds. * `:max_age` - the default maximum age in **seconds** of the token. Defaults to 86400 seconds (1 day) and it may be overridden on `decrypt/4`. """ @spec encrypt(context, binary, term, [shared_opt | max_age_opt | signed_at_opt]) :: binary def encrypt(context, secret, data, opts \\ []) when is_binary(secret) do context |> get_key_base() |> Plug.Crypto.encrypt(secret, data, opts) end @doc """ Decodes the original data from the token and verifies its integrity. ## Examples In this scenario we will create a token, sign it, then provide it to a client application. The client will then use this token to authenticate requests for resources from the server. See `Phoenix.Token` summary for more info about creating tokens. iex> user_id = 99 iex> secret = "kjoy3o1zeidquwy1398juxzldjlksahdk3" iex> namespace = "user auth" iex> token = Phoenix.Token.sign(secret, namespace, user_id) The mechanism for passing the token to the client is typically through a cookie, a JSON response body, or HTTP header. For now, assume the client has received a token it can use to validate requests for protected resources. When the server receives a request, it can use `verify/4` to determine if it should provide the requested resources to the client: iex> Phoenix.Token.verify(secret, namespace, token, max_age: 86400) {:ok, 99} In this example, we know the client sent a valid token because `verify/4` returned a tuple of type `{:ok, user_id}`. The server can now proceed with the request. However, if the client had sent an expired token, an invalid token, or `nil`, `verify/4` would have returned an error instead: iex> Phoenix.Token.verify(secret, namespace, expired, max_age: 86400) {:error, :expired} iex> Phoenix.Token.verify(secret, namespace, invalid, max_age: 86400) {:error, :invalid} iex> Phoenix.Token.verify(secret, namespace, nil, max_age: 86400) {:error, :missing} ## Options * `:key_iterations` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 1000 * `:key_length` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 32 * `:key_digest` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to `:sha256` * `:max_age` - verifies the token only if it has been generated "max age" ago in seconds. Defaults to the max age signed in the token by `sign/4`. """ @spec verify(context, binary, binary, [shared_opt | max_age_opt]) :: {:ok, term} | {:error, :expired | :invalid | :missing} def verify(context, salt, token, opts \\ []) when is_binary(salt) do context |> get_key_base() |> Plug.Crypto.verify(salt, token, opts) end @doc """ Decrypts the original data from the token and verifies its integrity. Its usage is identical to `verify/4` but for encrypted tokens. ## Options * `:key_iterations` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 1000 * `:key_length` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to 32 * `:key_digest` - option passed to `Plug.Crypto.KeyGenerator` when generating the encryption and signing keys. Defaults to `:sha256` * `:max_age` - verifies the token only if it has been generated "max age" ago in seconds. Defaults to the max age signed in the token by `encrypt/4`. """ @spec decrypt(context, binary, binary, [shared_opt | max_age_opt]) :: term() def decrypt(context, secret, token, opts \\ []) when is_binary(secret) do context |> get_key_base() |> Plug.Crypto.decrypt(secret, token, opts) end ## Helpers defp get_key_base(%Plug.Conn{} = conn), do: conn |> Phoenix.Controller.endpoint_module() |> get_endpoint_key_base() defp get_key_base(%_{endpoint: endpoint}), do: get_endpoint_key_base(endpoint) defp get_key_base(endpoint) when is_atom(endpoint), do: get_endpoint_key_base(endpoint) defp get_key_base(string) when is_binary(string) and byte_size(string) >= 20, do: string defp get_endpoint_key_base(endpoint) do endpoint.config(:secret_key_base) || raise """ no :secret_key_base configuration found in #{inspect(endpoint)}. Ensure your environment has the necessary mix configuration. For example: config :my_app, MyAppWeb.Endpoint, secret_key_base: ... """ end end ================================================ FILE: lib/phoenix/transports/long_poll.ex ================================================ defmodule Phoenix.Transports.LongPoll do @moduledoc false @behaviour Plug # 10MB @max_base64_size 10_000_000 @connect_info_opts [:check_csrf] import Plug.Conn alias Phoenix.Socket.{V1, V2, Transport} def default_config() do [ window_ms: 10_000, path: "/longpoll", pubsub_timeout_ms: 2_000, serializer: [{V1.JSONSerializer, "~> 1.0.0"}, {V2.JSONSerializer, "~> 2.0.0"}], transport_log: false, crypto: [max_age: 1_209_600] ] end def init(opts), do: opts def call(conn, {endpoint, handler, opts}) do conn |> fetch_query_params() |> put_resp_header("access-control-allow-origin", "*") |> Transport.code_reload(endpoint, opts) |> Transport.transport_log(opts[:transport_log]) |> Transport.check_origin(handler, endpoint, opts, &status_json/1) |> dispatch(endpoint, handler, opts) end defp dispatch(%{halted: true} = conn, _, _, _) do conn end # Responds to pre-flight CORS requests with Allow-Origin-* headers. # We allow cross-origin requests as we always validate the Origin header. defp dispatch(%{method: "OPTIONS"} = conn, _, _, _) do headers = get_req_header(conn, "access-control-request-headers") |> Enum.join(", ") conn |> put_resp_header("access-control-allow-headers", headers) |> put_resp_header("access-control-allow-methods", "get, post, options") |> put_resp_header("access-control-max-age", "3600") |> send_resp(:ok, "") end # Starts a new session or listen to a message if one already exists. defp dispatch(%{method: "GET"} = conn, endpoint, handler, opts) do case resume_session(conn, conn.params, endpoint, opts) do {:ok, new_conn, server_ref} -> listen(new_conn, server_ref, endpoint, opts) :error -> new_session(conn, endpoint, handler, opts) end end # Publish the message. defp dispatch(%{method: "POST"} = conn, endpoint, _, opts) do case resume_session(conn, conn.params, endpoint, opts) do {:ok, new_conn, server_ref} -> publish(new_conn, server_ref, endpoint, opts) :error -> conn |> put_status(:gone) |> status_json() end end # All other requests should fail. defp dispatch(conn, _, _, _) do send_resp(conn, :bad_request, "") end defp publish(conn, server_ref, endpoint, opts) do case read_body(conn, []) do {:ok, body, conn} -> # we need to match on both v1 and v2 protocol, as well as wrap for backwards compat batch = case get_req_header(conn, "content-type") do ["application/x-ndjson"] -> body |> String.split(["\n", "\r\n"]) |> Enum.map(fn "[" <> _ = txt -> {txt, :text} base64 -> {safe_decode64!(base64), :binary} end) _ -> [{body, :text}] end {conn, status} = Enum.reduce_while(batch, {conn, nil}, fn msg, {conn, _status} -> case transport_dispatch(endpoint, server_ref, msg, opts) do :ok -> {:cont, {conn, :ok}} :request_timeout = timeout -> {:halt, {conn, timeout}} end end) conn |> put_status(status) |> status_json() _ -> raise Plug.BadRequestError end end defp safe_decode64!(base64) do if byte_size(base64) <= @max_base64_size do Base.decode64!(base64) else raise Plug.BadRequestError end end defp transport_dispatch(endpoint, server_ref, body, opts) do ref = make_ref() broadcast_from!(endpoint, server_ref, {:dispatch, client_ref(server_ref), body, ref}) receive do {:ok, ^ref} -> :ok {:error, ^ref} -> :ok after opts[:window_ms] -> :request_timeout end end ## Session handling defp new_session(conn, endpoint, handler, opts) do priv_topic = "phx:lp:" <> Base.encode64(:crypto.strong_rand_bytes(16)) <> (System.system_time(:millisecond) |> Integer.to_string()) keys = Keyword.get(opts, :connect_info, []) conn = maybe_auth_token_from_header(conn, opts[:auth_token]) connect_info = Transport.connect_info(conn, endpoint, keys, Keyword.take(opts, @connect_info_opts)) arg = {endpoint, handler, opts, conn.params, priv_topic, connect_info} spec = {Phoenix.Transports.LongPoll.Server, arg} case DynamicSupervisor.start_child(Phoenix.Transports.LongPoll.Supervisor, spec) do :ignore -> conn |> put_status(:forbidden) |> status_json() {:ok, server_pid} -> data = {:v1, endpoint.config(:endpoint_id), server_pid, priv_topic} token = sign_token(endpoint, data, opts) conn |> put_status(:gone) |> status_token_messages_json(token, []) end end defp listen(conn, server_ref, endpoint, opts) do ref = make_ref() client_ref = client_ref(server_ref) broadcast_from!(endpoint, server_ref, {:flush, client_ref, ref}) {status, messages} = receive do {:messages, messages, ^ref} -> {:ok, messages} {:now_available, ^ref} -> broadcast_from!(endpoint, server_ref, {:flush, client_ref, ref}) receive do {:messages, messages, ^ref} -> {:ok, messages} after opts[:window_ms] -> broadcast_from!(endpoint, server_ref, {:expired, client_ref, ref}) {:no_content, []} end after opts[:window_ms] -> broadcast_from!(endpoint, server_ref, {:expired, client_ref, ref}) {:no_content, []} end conn |> put_status(status) |> status_token_messages_json(conn.params["token"], messages) end # Retrieves the serialized `Phoenix.LongPoll.Server` pid # by publishing a message in the encrypted private topic. defp resume_session(%Plug.Conn{} = conn, %{"token" => token}, endpoint, opts) do case verify_token(endpoint, token, opts) do {:ok, {:v1, id, pid, priv_topic}} -> server_ref = server_ref(endpoint.config(:endpoint_id), id, pid, priv_topic) new_conn = Plug.Conn.register_before_send(conn, fn conn -> unsubscribe(endpoint, server_ref) conn end) ref = make_ref() :ok = subscribe(endpoint, server_ref) broadcast_from!(endpoint, server_ref, {:subscribe, client_ref(server_ref), ref}) receive do {:subscribe, ^ref} -> {:ok, new_conn, server_ref} after opts[:pubsub_timeout_ms] -> :error end _ -> :error end end defp resume_session(%Plug.Conn{}, _params, _endpoint, _opts), do: :error ## Helpers defp server_ref(endpoint_id, id, pid, topic) when is_pid(pid) do cond do node(pid) in Node.list() -> pid endpoint_id == id and Process.alive?(pid) -> pid true -> topic end end defp client_ref(topic) when is_binary(topic), do: topic defp client_ref(pid) when is_pid(pid), do: self() defp subscribe(endpoint, topic) when is_binary(topic), do: Phoenix.PubSub.subscribe(endpoint.config(:pubsub_server), topic) defp subscribe(_endpoint, pid) when is_pid(pid), do: :ok defp unsubscribe(endpoint, topic) when is_binary(topic), do: Phoenix.PubSub.unsubscribe(endpoint.config(:pubsub_server), topic) defp unsubscribe(_endpoint, pid) when is_pid(pid), do: :ok defp broadcast_from!(endpoint, topic, msg) when is_binary(topic), do: Phoenix.PubSub.broadcast_from!(endpoint.config(:pubsub_server), self(), topic, msg) defp broadcast_from!(_endpoint, pid, msg) when is_pid(pid), do: send(pid, msg) defp sign_token(endpoint, data, opts) do Phoenix.Token.sign( endpoint, Atom.to_string(endpoint.config(:pubsub_server)), data, opts[:crypto] ) end defp verify_token(endpoint, signed, opts) do Phoenix.Token.verify( endpoint, Atom.to_string(endpoint.config(:pubsub_server)), signed, opts[:crypto] ) end defp maybe_auth_token_from_header(conn, true) do case Plug.Conn.get_req_header(conn, "x-phoenix-authtoken") do [] -> conn [token | _] -> Plug.Conn.put_private(conn, :phoenix_transport_auth_token, token) end end defp maybe_auth_token_from_header(conn, _), do: conn defp status_json(conn) do send_json(conn, %{"status" => conn.status || 200}) end defp status_token_messages_json(conn, token, messages) do send_json(conn, %{"status" => conn.status || 200, "token" => token, "messages" => messages}) end defp send_json(conn, data) do conn |> put_resp_header("content-type", "application/json; charset=utf-8") |> send_resp(200, Phoenix.json_library().encode_to_iodata!(data)) end end ================================================ FILE: lib/phoenix/transports/long_poll_server.ex ================================================ defmodule Phoenix.Transports.LongPoll.Server do @moduledoc false use GenServer, restart: :temporary alias Phoenix.PubSub def start_link(arg) do GenServer.start_link(__MODULE__, arg) end def init({endpoint, handler, options, params, priv_topic, connect_info}) do config = %{ endpoint: endpoint, transport: :longpoll, options: options, params: params, connect_info: connect_info } window_ms = Keyword.fetch!(options, :window_ms) case handler.connect(config) do {:ok, handler_state} -> {:ok, handler_state} = handler.init(handler_state) state = %{ buffer: [], handler: {handler, handler_state}, window_ms: trunc(window_ms * 1.5), pubsub_server: endpoint.config(:pubsub_server), priv_topic: priv_topic, last_client_poll: now_ms(), client_ref: nil } :ok = PubSub.subscribe(state.pubsub_server, priv_topic) schedule_inactive_shutdown(state.window_ms) {:ok, state} :error -> :ignore {:error, _reason} -> :ignore end end def handle_info({:dispatch, client_ref, {body, opcode}, ref}, state) do %{handler: {handler, handler_state}} = state case handler.handle_in({body, opcode: opcode}, handler_state) do {:reply, status, {_, reply}, handler_state} -> state = %{state | handler: {handler, handler_state}} status = if status == :ok, do: :ok, else: :error broadcast_from!(state, client_ref, {status, ref}) publish_reply(state, reply) {:ok, handler_state} -> state = %{state | handler: {handler, handler_state}} broadcast_from!(state, client_ref, {:ok, ref}) {:noreply, state} {:stop, reason, handler_state} -> state = %{state | handler: {handler, handler_state}} broadcast_from!(state, client_ref, {:error, ref}) {:stop, reason, state} end end def handle_info({:subscribe, client_ref, ref}, state) do broadcast_from!(state, client_ref, {:subscribe, ref}) {:noreply, state} end def handle_info({:flush, client_ref, ref}, state) do case state.buffer do [] -> {:noreply, %{state | client_ref: {client_ref, ref}, last_client_poll: now_ms()}} buffer -> broadcast_from!(state, client_ref, {:messages, Enum.reverse(buffer), ref}) {:noreply, %{state | client_ref: nil, last_client_poll: now_ms(), buffer: []}} end end def handle_info({:expired, client_ref, ref}, state) do case state.client_ref do {^client_ref, ^ref} -> {:noreply, %{state | client_ref: nil}} _ -> {:noreply, state} end end def handle_info(:shutdown_if_inactive, state) do if now_ms() - state.last_client_poll > state.window_ms do {:stop, {:shutdown, :inactive}, state} else schedule_inactive_shutdown(state.window_ms) {:noreply, state} end end def handle_info(message, state) do %{handler: {handler, handler_state}} = state case handler.handle_info(message, handler_state) do {:push, {_, reply}, handler_state} -> state = %{state | handler: {handler, handler_state}} publish_reply(state, reply) {:ok, handler_state} -> state = %{state | handler: {handler, handler_state}} {:noreply, state} {:stop, reason, handler_state} -> state = %{state | handler: {handler, handler_state}} {:stop, reason, state} end end def terminate(reason, state) do %{handler: {handler, handler_state}} = state handler.terminate(reason, handler_state) :ok end defp broadcast_from!(state, client_ref, msg) when is_binary(client_ref), do: PubSub.broadcast_from!(state.pubsub_server, self(), client_ref, msg) defp broadcast_from!(_state, client_ref, msg) when is_pid(client_ref), do: send(client_ref, msg) defp publish_reply(state, reply) when is_map(reply) do IO.warn( "Returning a map from the LongPolling serializer is deprecated. " <> "Please return JSON encoded data instead (see Phoenix.Socket.Serializer)" ) publish_reply(state, Phoenix.json_library().encode_to_iodata!(reply)) end defp publish_reply(state, reply) do notify_client_now_available(state) {:noreply, update_in(state.buffer, &[IO.iodata_to_binary(reply) | &1])} end defp notify_client_now_available(state) do case state.client_ref do {client_ref, ref} -> broadcast_from!(state, client_ref, {:now_available, ref}) nil -> :ok end end defp now_ms, do: System.system_time(:millisecond) defp schedule_inactive_shutdown(window_ms) do Process.send_after(self(), :shutdown_if_inactive, window_ms) end end ================================================ FILE: lib/phoenix/transports/websocket.ex ================================================ defmodule Phoenix.Transports.WebSocket do @moduledoc false # # How WebSockets Work In Phoenix # # WebSocket support in Phoenix is implemented on top of the `WebSockAdapter` library. Upgrade # requests from clients originate as regular HTTP requests that get routed to this module via # Plug. These requests are then upgraded to WebSocket connections via # `WebSockAdapter.upgrade/4`, which takes as an argument the handler for a given socket endpoint # as configured in the application's Endpoint. This handler module must implement the # transport-agnostic `Phoenix.Socket.Transport` behaviour (this same behaviour is also used for # other transports such as long polling). Because this behaviour is a superset of the `WebSock` # behaviour, the `WebSock` library is able to use the callbacks in the `WebSock` behaviour to # call this handler module directly for the rest of the WebSocket connection's lifetime. # @behaviour Plug @connect_info_opts [:check_csrf] @auth_token_prefix "base64url.bearer.phx." import Plug.Conn alias Phoenix.Socket.{V1, V2, Transport} def default_config() do [ path: "/websocket", serializer: [{V1.JSONSerializer, "~> 1.0.0"}, {V2.JSONSerializer, "~> 2.0.0"}], error_handler: {__MODULE__, :handle_error, []}, timeout: 60_000, transport_log: false, compress: false ] end def init(opts), do: opts def call(%{method: "GET"} = conn, {endpoint, handler, opts}) do subprotocols = if opts[:auth_token] do # when using Sec-WebSocket-Protocol for passing an auth token # the server must reply with one of the subprotocols in the request; # therefore we include "phoenix" as allowed subprotocol and include it on the client ["phoenix" | Keyword.get(opts, :subprotocols, [])] else opts[:subprotocols] end conn |> fetch_query_params() |> Transport.code_reload(endpoint, opts) |> Transport.transport_log(opts[:transport_log]) |> Transport.check_origin(handler, endpoint, opts) |> maybe_auth_token_from_header(opts[:auth_token]) |> Transport.check_subprotocols(subprotocols) |> case do %{halted: true} = conn -> conn %{params: params} = conn -> keys = Keyword.get(opts, :connect_info, []) connect_info = Transport.connect_info(conn, endpoint, keys, Keyword.take(opts, @connect_info_opts)) config = %{ endpoint: endpoint, transport: :websocket, options: opts, params: params, connect_info: connect_info } case handler.connect(config) do {:ok, arg} -> try do conn |> WebSockAdapter.upgrade(handler, arg, opts) |> halt() rescue e in WebSockAdapter.UpgradeError -> send_resp(conn, 400, e.message) end :error -> send_resp(conn, 403, "") {:error, reason} -> {m, f, args} = opts[:error_handler] apply(m, f, [conn, reason | args]) end end end def call(conn, _), do: send_resp(conn, 400, "") def handle_error(conn, _reason), do: send_resp(conn, 403, "") defp maybe_auth_token_from_header(conn, true) do case get_req_header(conn, "sec-websocket-protocol") do [] -> conn [subprotocols_header | _] -> request_subprotocols = subprotocols_header |> Plug.Conn.Utils.list() |> Enum.split_with(&String.starts_with?(&1, @auth_token_prefix)) case request_subprotocols do {[@auth_token_prefix <> encoded_token], actual_subprotocols} -> token = Base.decode64!(encoded_token, padding: false) conn |> put_private(:phoenix_transport_auth_token, token) |> set_actual_subprotocols(actual_subprotocols) _ -> conn end end end defp maybe_auth_token_from_header(conn, _), do: conn defp set_actual_subprotocols(conn, []), do: delete_req_header(conn, "sec-websocket-protocol") defp set_actual_subprotocols(conn, subprotocols), do: put_req_header(conn, "sec-websocket-protocol", Enum.join(subprotocols, ", ")) end ================================================ FILE: lib/phoenix/verified_routes.ex ================================================ defmodule Phoenix.VerifiedRoutes do @moduledoc ~S''' Provides route generation with compile-time verification. Use of the `sigil_p` macro allows paths and URLs throughout your application to be compile-time verified against your Phoenix router(s). For example, the following path and URL usages: ~H""" Log in """ redirect(to: url(~p"/posts/#{post}")) Will be verified against your standard `Phoenix.Router` definitions: get "/posts/:post_id", PostController, :show post "/sessions/new", SessionController, :create Unmatched routes will issue compiler warnings: ```console warning: no route path for AppWeb.Router matches "/postz/#{post}" lib/app_web/controllers/post_controller.ex:100: AppWeb.PostController.show/2 ``` Additionally, interpolated ~p values are encoded via the `Phoenix.Param` protocol. For example, a `%Post{}` struct in your application may derive the `Phoenix.Param` protocol to generate slug-based paths rather than ID based ones. This allows you to use `~p"/posts/#{post}"` rather than `~p"/posts/#{post.slug}"` throughout your application. See the `Phoenix.Param` documentation for more details. Finally, query strings are also supported in verified routes, either in traditional form: ~p"/posts?page=#{page}" Or as a keyword list or map of values: params = %{page: 1, direction: "asc"} ~p"/posts?#{params}" Like path segments, query strings params are proper URL encoded and may be interpolated directly into the ~p string. To ease url comparisons during tests (e.g. when using `assert_redirect/3`) query params will be sorted. This is controlled by the `phoenix: [sort_verified_routes_query_params: true]` configuration option. ## What about named routes? Many web frameworks, and early versions of Phoenix, provided a feature called "named routes". The idea is that, when you define routes in your web applications, you could give them names too. In Phoenix that was done as follows: get "/login", SessionController, :create, as: :login And now you could generate the route using the `login_path` function. Named routes exist to avoid hardcoding routes in your templates, if you wrote `` and then changed your router, the link would point to a page that no longer exist. By using `login_path`, we make sure it always points to a valid URL in our router. However, named routes come with the downsides of indirection: when you look at the code, it is not immediately clear which URL will be generated. Furthermore, if you have an existing URL and you want to add it to a template, you need to do a reverse lookup and find its name in the router. At the end of the day, named routes are arbitrary names that need to be memorized by developers, adding cognitive overhead. Verified routes tackle this problem by allowing the routes to be written as we would read them in a browser, but using the `~p` sigil to guarantee they actually exist at compilation time. They remove the indirection of named routes while keeping their guarantees. In any case, if part of your application requires features similar to named routes, then remember you can still leverage Elixir features to achieve the same result. For example, you can define several functions as named routes to be reused across modules: def login_path, do: ~p"/login" def user_home_path(user), do: ~p"/users/#{user.username}" ## Options To verify routes in your application modules, such as controller, templates, and views, `use Phoenix.VerifiedRoutes`, which supports the following options: * `:router` - The required router to verify `~p` paths against * `:endpoint` - Optional endpoint for URL generation * `:statics` - Optional list of static directories to treat as verified paths * `:path_prefixes` - Optional list of path prefixes to be added to every generated path. See "Path prefixes" for more information For example: use Phoenix.VerifiedRoutes, router: AppWeb.Router, endpoint: AppWeb.Endpoint, statics: ~w(images) ## Connection/socket-based route generation The majority of path and URL generation needs your application will be met with `~p` and `url/1`, where all information necessary to construct the path or URL is provided by the compile-time information stored in the Endpoint and Router passed to `use Phoenix.VerifiedRoutes`. That said, there are some circumstances where `path/2`, `path/3`, `url/2`, and `url/3` are required: * When the runtime values of the `%Plug.Conn{}`, `%Phoenix.LiveSocket{}`, or a `%URI{}` dictate the formation of the path or URL, which happens under the following scenarios: - `Phoenix.Controller.put_router_url/2` is used to override the endpoint's URL - `Phoenix.Controller.put_static_url/2` is used to override the endpoint's static URL * When the Router module differs from the one passed to `use Phoenix.VerifiedRoutes`, such as library code, or application code that relies on multiple routers. In such cases, the router module can be provided explicitly to `path/3` and `url/3`. ## Tracking warnings All static path segments must start with forward slash, and you must have a static segment between dynamic interpolations in order for a route to be verified without warnings. For example, imagine you have these two routes: get "/media/posts/:id" get "/media/images/:id" The following route will be verified and emit a warning as it does not match the router: ~p"/media/post/#{post}" However the one below will not, the "post" segment is dynamic: type = "post" ~p"/media/#{type}/#{post}" If you find yourself needing to generate dynamic URLs which are defined statically in the router, that's a good indicator you should refactor it into one or more function, such as `posts_path/1` and `images_path/1`. Like any other compilation warning, the Elixir compiler will warn any time the file that a `~p` resides in changes, or if the router is changed. ## Localized routes and path prefixes Applications that need to support internationalization (i18n) and localization (l10n) often do so at the URL level. In such cases, there are different approaches one can choose. One option is to perform i18n at the domain level. You can have `example.com` (in which you would detect the locale based on the "Accept-Language" HTTP header), `en.example.com`, `en-GB.example.com` and so forth. In this case, you would have a plug that looks at the host and at HTTP headers and calls `Gettext.get_locale/1` accordingly. The biggest benefit of this approach is that you don't have to change the routes in your application and verified routes works as is. Some applications, however, like to add the locale as part of the URL prefix: scope "/:locale" do get "/posts" get "/images" end For such cases, VerifiedRoutes allow you to configure a `path_prefixes` option, which is a list of segments to prepend to the URL. For example: use Phoenix.VerifiedRoutes, router: AppWeb.Router, endpoint: AppWeb.Endpoint, path_prefixes: [{Gettext, :get_locale, []}] The above will prepend `"/#{Gettext.get_locale()}"` to every path and url generated with `~p`. If your website has a handful of URLs that do not require the locale prefix, then we suggest defining them in a separate module, where you use `Phoenix.VerifiedRoutes` without the prefix option: defmodule UnlocalizedRoutes do use Phoenix.VerifiedRoutes, router: AppWeb.Router, endpoint: AppWeb.Endpoint # Since :path_prefixes was not declared, # the code below won't prepend the locale and still be verified def root, do: ~p"/" end Finally, for even more complex use cases, where the whole URL needs to localized, see projects such as [`routex`](https://hex.pm/packages/routex) and [`ex_cldr_routes`](https://hex.pm/packages/ex_cldr_routes). ## Usage with custom plugs Sometimes, when we want to do dynamic routing, we will forward to custom plugs. It is possible to make these dynamic routers support `mix phx.routes` and verified routes at compile time by adopting the `Phoenix.VerifiedRoutes` behaviour. For example: defmodule MyApp.LocaleRouter do use Plug.Router @behaviour Phoenix.VerifiedRoutes # custom routing rules # for displaying in `mix phx.routes` def formatted_routes(plug_opts) do for locale <- supported_locales(plug_opts) do %{verb: "GET", path: "/#{locale}/*subpath"} end end def verified_route?(plug_opts, path) do plug_opts |> supported_locales() |> Enum.any?(fn locale -> Enum.at(path, 0) == locale end) end end ''' @doc false defstruct router: nil, route: nil, inspected_route: nil, warn_location: nil, test_path: nil defmacro __using__(opts) do opts = if Keyword.keyword?(opts) do for {k, v} <- opts do if Macro.quoted_literal?(v) do {k, Macro.prewalk(v, &expand_alias(&1, __CALLER__))} else {k, v} end end else opts end quote do unquote(__MODULE__).__using__(__MODULE__, unquote(opts)) import unquote(__MODULE__) end end @doc false def __using__(mod, opts) do Module.register_attribute(mod, :phoenix_verified_routes, accumulate: true) Module.put_attribute(mod, :before_compile, __MODULE__) Module.put_attribute(mod, :router, Keyword.fetch!(opts, :router)) Module.put_attribute(mod, :endpoint, Keyword.get(opts, :endpoint)) statics = case Keyword.get(opts, :statics, []) do list when is_list(list) -> list other -> raise ArgumentError, "expected statics to be a list, got: #{inspect(other)}" end path_prefixes = case Keyword.get(opts, :path_prefixes, []) do list when is_list(list) -> list other -> raise ArgumentError, "expected path_prefixes to be a list of zero-arity functions, got: #{inspect(other)}" end if Module.get_attribute(mod, :phoenix_verified_config) do raise "duplicate call to \"use Phoenix.VerifiedRoutes\" found, make sure it is used only once per module" end Module.put_attribute(mod, :phoenix_verified_config, %{ statics: statics, path_prefixes: path_prefixes }) end @type plug_opts :: any() @type formatted_route :: %{ required(:verb) => String.t(), required(:path) => String.t(), required(:label) => String.t() } @doc """ Returns the necessary information about routes for display in `mix phx.routes`. The `plug_opts` is typically only passed when the router is mounted within a `Phoenix.Router`. Otherwise it defaults to `[]`. """ @callback formatted_routes(plug_opts()) :: [formatted_route()] @doc """ Returns `true` if the path is verified, and false if not. The `plug_opts` is typically only passed when the router is mounted within a `Phoenix.Router`. Otherwise it defaults to `[]`. """ @callback verified_route?(plug_opts(), [String.t()]) :: boolean() defmacro __before_compile__(_env) do quote do @after_verify {__MODULE__, :__phoenix_verify_routes__} @doc false def __phoenix_verify_routes__(_module) do unquote(__MODULE__).__verify__(@phoenix_verified_routes) end end end @doc false def __verify__(routes) when is_list(routes) do Enum.each(routes, fn %__MODULE__{} = route -> test_path = split_test_path(route.test_path) unless route.router.verified_route?([], test_path) do IO.warn( "no route path for #{inspect(route.router)} matches #{route.inspected_route}", route.warn_location ) end end) end defp split_test_path(test_path) do test_path |> String.split("#") |> Enum.at(0) |> String.split("/") |> Enum.filter(fn segment -> segment != "" end) |> Enum.map(&URI.decode/1) end defp expand_alias({:__aliases__, _, _} = alias, env), do: Macro.expand(alias, %{env | function: {:path, 2}}) defp expand_alias(other, _env), do: other @doc ~S''' Generates the router path with route verification. Interpolated named parameters are encoded via the `Phoenix.Param` protocol. Warns when the provided path does not match against the router specified in `use Phoenix.VerifiedRoutes` or the `@router` module attribute. ## Examples use Phoenix.VerifiedRoutes, endpoint: MyAppWeb.Endpoint, router: MyAppWeb.Router redirect(to: ~p"/users/top") redirect(to: ~p"/users/#{@user}") ~H""" <.link href={~p"/users?page=#{@page}"}>profile <.link href={~p"/users?#{@params}"}>profile """ ''' defmacro sigil_p({:<<>>, _meta, _segments} = route, extra) do validate_sigil_p!(extra) endpoint = attr!(__CALLER__, :endpoint) router = attr!(__CALLER__, :router) route |> build_route(route, __CALLER__, endpoint, router) |> inject_path(__CALLER__) end defp inject_path( {%__MODULE__{} = route, static?, _endpoint_ctx, _route_ast, path_ast, static_ast}, env ) do if static? do static_ast else Module.put_attribute(env.module, :phoenix_verified_routes, route) path_ast end end defp inject_url( {%__MODULE__{} = route, static?, endpoint_ctx, route_ast, path_ast, _static_ast}, env ) do if static? do quote do unquote(__MODULE__).static_url(unquote_splicing([endpoint_ctx, route_ast])) end else Module.put_attribute(env.module, :phoenix_verified_routes, route) quote do unquote(__MODULE__).unverified_url(unquote_splicing([endpoint_ctx, path_ast])) end end end defp validate_sigil_p!([]), do: :ok defp validate_sigil_p!(extra) do raise ArgumentError, "~p does not support modifiers after closing, got: #{extra}" end defp raise_invalid_route(ast) do raise ArgumentError, "expected compile-time ~p path string, got: #{Macro.to_string(ast)}\n" <> "Use unverified_path/2 and unverified_url/2 if you need to build an arbitrary path." end @doc ~S''' Generates the router path with route verification. See `sigil_p/2` for more information. Warns when the provided path does not match against the router specified in the router argument. ## Examples import Phoenix.VerifiedRoutes redirect(to: path(conn, MyAppWeb.Router, ~p"/users/top")) redirect(to: path(conn, MyAppWeb.Router, ~p"/users/#{@user}")) ~H""" <.link href={path(@uri, MyAppWeb.Router, "/users?page=#{@page}")}>profile <.link href={path(@uri, MyAppWeb.Router, "/users?#{@params}")}>profile """ ''' defmacro path( conn_or_socket_or_endpoint_or_uri, router, {:sigil_p, _, [{:<<>>, _meta, _segments} = route, extra]} = sigil_p ) do validate_sigil_p!(extra) route |> build_route(sigil_p, __CALLER__, conn_or_socket_or_endpoint_or_uri, router) |> inject_path(__CALLER__) end defmacro path(_endpoint, _router, other), do: raise_invalid_route(other) @doc ~S''' Generates the router path with route verification. See `sigil_p/2` for more information. Warns when the provided path does not match against the router specified in `use Phoenix.VerifiedRoutes` or the `@router` module attribute. ## Examples import Phoenix.VerifiedRoutes redirect(to: path(conn, ~p"/users/top")) redirect(to: path(conn, ~p"/users/#{@user}")) ~H""" <.link href={path(@uri, "/users?page=#{@page}")}>profile <.link href={path(@uri, "/users?#{@params}")}>profile """ ''' defmacro path( conn_or_socket_or_endpoint_or_uri, {:sigil_p, _, [{:<<>>, _meta, _segments} = route, extra]} = sigil_p ) do validate_sigil_p!(extra) router = attr!(__CALLER__, :router) route |> build_route(sigil_p, __CALLER__, conn_or_socket_or_endpoint_or_uri, router) |> inject_path(__CALLER__) end defmacro path(_conn_or_socket_or_endpoint_or_uri, other), do: raise_invalid_route(other) @doc ~S''' Generates the router url with route verification. See `sigil_p/2` for more information. Warns when the provided path does not match against the router specified in `use Phoenix.VerifiedRoutes` or the `@router` module attribute. ## Examples use Phoenix.VerifiedRoutes, endpoint: MyAppWeb.Endpoint, router: MyAppWeb.Router redirect(to: url(conn, ~p"/users/top")) redirect(to: url(conn, ~p"/users/#{@user}")) ~H""" <.link href={url(@uri, "/users?#{[page: @page]}")}>profile """ The router may also be provided in cases where you want to verify routes for a router other than the one passed to `use Phoenix.VerifiedRoutes`: redirect(to: url(conn, OtherRouter, ~p"/users")) Forwarded routes are also resolved automatically. For example, imagine you have a forward path to an admin router in your main router: defmodule AppWeb.Router do ... forward "/admin", AppWeb.AdminRouter end defmodule AppWeb.AdminRouter do ... get "/users", AppWeb.Admin.UserController end Forwarded paths in your main application router will be verified as usual, such as `~p"/admin/users"`. ''' defmacro url({:sigil_p, _, [{:<<>>, _meta, _segments} = route, _]} = sigil_p) do endpoint = attr!(__CALLER__, :endpoint) router = attr!(__CALLER__, :router) route |> build_route(sigil_p, __CALLER__, endpoint, router) |> inject_url(__CALLER__) end defmacro url(other), do: raise_invalid_route(other) @doc """ Generates the router url with route verification from the connection, socket, or URI. See `url/1` for more information. """ defmacro url( conn_or_socket_or_endpoint_or_uri, {:sigil_p, _, [{:<<>>, _meta, _segments} = route, _]} = sigil_p ) do router = attr!(__CALLER__, :router) route |> build_route(sigil_p, __CALLER__, conn_or_socket_or_endpoint_or_uri, router) |> inject_url(__CALLER__) end defmacro url(_conn_or_socket_or_endpoint_or_uri, other), do: raise_invalid_route(other) @doc """ Generates the url with route verification from the connection, socket, or URI and router. See `url/1` for more information. """ defmacro url( conn_or_socket_or_endpoint_or_uri, router, {:sigil_p, _, [{:<<>>, _meta, _segments} = route, _]} = sigil_p ) do router = Macro.expand(router, __CALLER__) route |> build_route(sigil_p, __CALLER__, conn_or_socket_or_endpoint_or_uri, router) |> inject_url(__CALLER__) end defmacro url(_conn_or_socket_or_endpoint_or_uri, _router, other), do: raise_invalid_route(other) @doc """ Generates url to a static asset given its file path. See `c:Phoenix.Endpoint.static_url/0` and `c:Phoenix.Endpoint.static_path/1` for more information. ## Examples iex> static_url(conn, "/assets/js/app.js") "https://example.com/assets/js/app-813dfe33b5c7f8388bccaaa38eec8382.js" iex> static_url(socket, "/assets/js/app.js") "https://example.com/assets/js/app-813dfe33b5c7f8388bccaaa38eec8382.js" iex> static_url(AppWeb.Endpoint, "/assets/js/app.js") "https://example.com/assets/js/app-813dfe33b5c7f8388bccaaa38eec8382.js" """ def static_url(conn_or_socket_or_endpoint, path) def static_url(%Plug.Conn{private: private}, path) do case private do %{phoenix_static_url: static_url} -> concat_url(static_url, path) %{phoenix_endpoint: endpoint} -> static_url(endpoint, path) end end def static_url(%_{endpoint: endpoint}, path) do static_url(endpoint, path) end def static_url(endpoint, path) when is_atom(endpoint) do endpoint.static_url() <> endpoint.static_path(path) end def static_url(other, path) do raise ArgumentError, "expected a %Plug.Conn{}, a %Phoenix.Socket{}, a struct with an :endpoint key, " <> "or a Phoenix.Endpoint when building static url for #{path}, got: #{inspect(other)}" end @doc """ Returns the URL for the endpoint from the path without verification. ## Examples iex> unverified_url(conn, "/posts") "https://example.com/posts" iex> unverified_url(conn, "/posts", page: 1) "https://example.com/posts?page=1" """ def unverified_url(conn_or_socket_or_endpoint_or_uri, path, params \\ %{}) when (is_map(params) or is_list(params)) and is_binary(path) do guarded_unverified_url(conn_or_socket_or_endpoint_or_uri, path, params) end defp guarded_unverified_url(%Plug.Conn{private: private}, path, params) do case private do %{phoenix_router_url: url} when is_binary(url) -> concat_url(url, path, params) %{phoenix_endpoint: endpoint} -> concat_url(endpoint.url(), path, params) end end defp guarded_unverified_url(%_{endpoint: endpoint}, path, params) do concat_url(endpoint.url(), path, params) end defp guarded_unverified_url(%URI{} = uri, path, params) do append_params(URI.to_string(%{uri | path: path}), params) end defp guarded_unverified_url(endpoint, path, params) when is_atom(endpoint) do concat_url(endpoint.url(), path, params) end defp guarded_unverified_url(other, path, _params) do raise ArgumentError, "expected a %Plug.Conn{}, a %Phoenix.Socket{}, a %URI{}, a struct with an :endpoint key, " <> "or a Phoenix.Endpoint when building url at #{path}, got: #{inspect(other)}" end defp concat_url(url, path) when is_binary(path), do: url <> path defp concat_url(url, path, params) when is_binary(path) do append_params(url <> path, params) end @doc """ Generates path to a static asset given its file path. See `c:Phoenix.Endpoint.static_path/1` for more information. ## Examples iex> static_path(conn, "/assets/js/app.js") "/assets/js/app-813dfe33b5c7f8388bccaaa38eec8382.js" iex> static_path(socket, "assets/js/app.js") "/assets/js/app-813dfe33b5c7f8388bccaaa38eec8382.js" iex> static_path(AppWeb.Endpoint, "assets/js/app.js") "/assets/js/app-813dfe33b5c7f8388bccaaa38eec8382.js" iex> static_path(%URI{path: "/subresource"}, "/assets/js/app.js") "/subresource/assets/js/app-813dfe33b5c7f8388bccaaa38eec8382.js" """ def static_path(conn_or_socket_or_endpoint_or_uri, path) def static_path(%Plug.Conn{private: private}, path) do case private do %{phoenix_static_url: _} -> path %{phoenix_endpoint: endpoint} -> endpoint.static_path(path) end end def static_path(%URI{} = uri, path) do (uri.path || "") <> path end def static_path(%_{endpoint: endpoint}, path) do static_path(endpoint, path) end def static_path(endpoint, path) when is_atom(endpoint) do endpoint.static_path(path) end @doc """ Returns the path with relevant script name prefixes without verification. ## Examples iex> unverified_path(conn, AppWeb.Router, "/posts") "/posts" iex> unverified_path(conn, AppWeb.Router, "/posts", page: 1) "/posts?page=1" """ def unverified_path(conn_or_socket_or_endpoint_or_uri, router, path, params \\ %{}) def unverified_path(%Plug.Conn{} = conn, router, path, params) do conn |> build_own_forward_path(router, path) |> Kernel.||(build_conn_forward_path(conn, router, path)) |> Kernel.||(path_with_script(path, conn.script_name)) |> append_params(params) end def unverified_path(%URI{} = uri, _router, path, params) do append_params((uri.path || "") <> path, params) end def unverified_path(%_{endpoint: endpoint}, router, path, params) do unverified_path(endpoint, router, path, params) end def unverified_path(endpoint, _router, path, params) when is_atom(endpoint) do append_params(endpoint.path(path), params) end def unverified_path(other, router, path, _params) do raise ArgumentError, "expected a %Plug.Conn{}, a %Phoenix.Socket{}, a %URI{}, a struct with an :endpoint key, " <> "or a Phoenix.Endpoint when building path for #{inspect(router)} at #{path}, got: #{inspect(other)}" end defp append_params(path, params) when params == %{} or params == [], do: path defp append_params(path, params) when is_map(params) or is_list(params) do path <> "?" <> __encode_query__(params) end @doc false def __encode_segment__(data) do case data do [] -> "" [str | _] when is_binary(str) -> Enum.map_join(data, "/", &encode_segment/1) _ -> encode_segment(data) end end defp encode_segment(data) do data |> Phoenix.Param.to_param() |> URI.encode(&URI.char_unreserved?/1) end # Segments must always start with / defp verify_segment(["/" <> _ | _] = segments, route), do: verify_segment(segments, route, []) defp verify_segment(_, route) do raise ArgumentError, "paths must begin with /, got: #{Macro.to_string(route)}" end # separator followed by dynamic defp verify_segment(["/" | rest], route, acc), do: verify_segment(rest, route, ["/" | acc]) # we've found a static segment, return to caller with rewritten query if found defp verify_segment(["/" <> _ = segment | rest], route, acc) do case {String.split(segment, "?"), rest} do {[segment], _} -> verify_segment(rest, route, [URI.encode(segment) | acc]) {[segment, static_query], dynamic_query} -> {Enum.reverse([URI.encode(segment) | acc]), verify_query(dynamic_query, route, [static_query])} end end # we reached the static query string, return to caller defp verify_segment(["?" <> query], _route, acc) do {Enum.reverse(acc), [query]} end # we reached the dynamic query string, return to call with rewritten query defp verify_segment(["?" <> static_query_segment | rest], route, acc) do {Enum.reverse(acc), verify_query(rest, route, [static_query_segment])} end defp verify_segment([segment | _], route, _acc) when is_binary(segment) do raise ArgumentError, "path segments after interpolation must begin with /, got: #{inspect(segment)} in #{Macro.to_string(route)}" end defp verify_segment( [ {:"::", m1, [{{:., m2, [Kernel, :to_string]}, m3, [dynamic]}, {:binary, _, _} = bin]} | rest ], route, [prev | _] = acc ) when is_binary(prev) do rewrite = {:"::", m1, [{{:., m2, [__MODULE__, :__encode_segment__]}, m3, [dynamic]}, bin]} verify_segment(rest, route, [rewrite | acc]) end defp verify_segment([_ | _], route, _acc) do raise ArgumentError, "a dynamic ~p interpolation must follow a static segment, got: #{Macro.to_string(route)}" end # we've reached the end of the path without finding query, return to caller defp verify_segment([], _route, acc), do: {Enum.reverse(acc), _query = []} defp verify_query( [ {:"::", m1, [{{:., m2, [Kernel, :to_string]}, m3, [arg]}, {:binary, _, _} = bin]} | rest ], route, acc ) do unless is_binary(hd(acc)) do raise ArgumentError, "interpolated query string params must be separated by &, got: #{Macro.to_string(route)}" end sort_params? = Application.get_env(:phoenix, :sort_verified_routes_query_params, false) rewrite = {:"::", m1, [{{:., m2, [__MODULE__, :__encode_query__]}, m3, [arg, sort_params?]}, bin]} verify_query(rest, route, [rewrite | acc]) end defp verify_query([], _route, acc), do: Enum.reverse(acc) defp verify_query(["=" | rest], route, acc) do verify_query(rest, route, ["=" | acc]) end defp verify_query(["&" <> _ = param | rest], route, acc) do unless String.contains?(param, "=") do raise ArgumentError, "expected query string param key to end with = or declare a static key value pair, got: #{inspect(param)}" end verify_query(rest, route, [param | acc]) end defp verify_query(_other, route, _acc) do raise_invalid_query(route) end defp raise_invalid_query(route) do raise ArgumentError, "expected query string param to be compile-time map or keyword list, got: #{Macro.to_string(route)}" end @doc """ Generates an integrity hash to a static asset given its file path. See `c:Phoenix.Endpoint.static_integrity/1` for more information. ## Examples iex> static_integrity(conn, "/assets/js/app.js") "813dfe33b5c7f8388bccaaa38eec8382" iex> static_integrity(socket, "/assets/js/app.js") "813dfe33b5c7f8388bccaaa38eec8382" iex> static_integrity(AppWeb.Endpoint, "/assets/js/app.js") "813dfe33b5c7f8388bccaaa38eec8382" """ def static_integrity(conn_or_socket_or_endpoint, path) def static_integrity(%Plug.Conn{private: %{phoenix_endpoint: endpoint}}, path) do static_integrity(endpoint, path) end def static_integrity(%_{endpoint: endpoint}, path) do static_integrity(endpoint, path) end def static_integrity(endpoint, path) when is_atom(endpoint) do endpoint.static_integrity(path) end @doc false def __encode_query__(dict, sort? \\ false) def __encode_query__(dict, sort?) when is_list(dict) or (is_map(dict) and not is_struct(dict)) do case Plug.Conn.Query.encode(dict, &to_param/1) do "" -> "" query_str -> maybe_sort_query(query_str, sort?) end end def __encode_query__(val, _sort?), do: val |> to_param() |> URI.encode_www_form() defp maybe_sort_query(query_str, false), do: query_str defp maybe_sort_query(query, true), do: query |> String.split("&") |> Enum.sort() |> Enum.join("&") defp to_param(int) when is_integer(int), do: Integer.to_string(int) defp to_param(bin) when is_binary(bin), do: bin defp to_param(false), do: "false" defp to_param(true), do: "true" defp to_param(data), do: Phoenix.Param.to_param(data) defp build_route(route_ast, sigil_p, env, endpoint_ctx, router) do config = Module.get_attribute(env.module, :phoenix_verified_config, []) router = case Macro.expand(router, env) do mod when is_atom(mod) -> mod other -> raise ArgumentError, """ expected router to be to module, got: #{inspect(other)} If your router is not defined at compile-time, use unverified_path/3 instead. """ end {static?, meta, test_path, path_ast, static_ast} = rewrite_path(route_ast, endpoint_ctx, router, config) route = %__MODULE__{ router: router, warn_location: warn_location(meta, env), inspected_route: Macro.to_string(sigil_p), test_path: test_path } {route, static?, endpoint_ctx, route_ast, path_ast, static_ast} end defp warn_location(meta, %{line: line, file: file, function: function, module: module}) do column = if column = meta[:column], do: column + 2 [line: line, function: function, module: module, file: file, column: column] end defp rewrite_path(route, endpoint, router, config) do {:<<>>, meta, segments} = route {path_rewrite, query_rewrite} = verify_segment(segments, route) path_rewrite = if config.path_prefixes != [] and static_path?(path_rewrite |> Enum.slice(0, 1) |> materialize_path(), config.statics) do path_rewrite else compile_prefixes(config.path_prefixes, meta) ++ path_rewrite end rewrite_route = if query_rewrite == [] do {:<<>>, meta, path_rewrite} else quote generated: true do query_str = unquote({:<<>>, meta, query_rewrite}) path_str = unquote({:<<>>, meta, path_rewrite}) if query_str == "" do path_str else path_str <> "?" <> query_str end end end test_path = materialize_path(path_rewrite) static? = static_path?(test_path, config.statics) path_ast = quote generated: true do unquote(__MODULE__).unverified_path(unquote_splicing([endpoint, router, rewrite_route])) end static_ast = quote generated: true do unquote(__MODULE__).static_path(unquote_splicing([endpoint, rewrite_route])) end {static?, meta, test_path, path_ast, static_ast} end defp materialize_path(path) do Enum.map_join(path, &if(is_binary(&1), do: &1, else: "1")) end defp compile_prefixes(path_prefixes, meta) do Enum.flat_map(path_prefixes, fn {module, fun, args} when is_atom(module) and is_atom(fun) and is_list(args) -> [ "/", {:"::", meta, [{{:., meta, [module, fun]}, meta, Macro.escape(args)}, {:binary, meta, nil}]} ] other -> raise ArgumentError, ":path_prefixes option in VerifiedRoutes must be a {mod, fun, args} and return a string, got: #{inspect(other)}" end) end defp attr!(%{function: nil}, _) do raise "Phoenix.VerifiedRoutes can only be used inside functions, please move your usage of ~p to functions" end defp attr!(env, :endpoint) do Module.get_attribute(env.module, :endpoint) || raise """ expected @endpoint to be set. For dynamic endpoint resolution, use path/2 instead. for example: path(conn_or_socket, ~p"/my-path") """ end defp attr!(env, name) do Module.get_attribute(env.module, name) || raise "expected @#{name} module attribute to be set" end defp static_path?(path, statics) do Enum.find(statics, &String.starts_with?(path, "/" <> &1)) end defp build_own_forward_path(conn, router, path) do case conn.private do %{^router => local_script} when is_list(local_script) -> path_with_script(path, local_script) %{} -> nil end end defp build_conn_forward_path(%Plug.Conn{} = conn, router, path) do with %{phoenix_router: phx_router} <- conn.private, %{^phx_router => script_name} when is_list(script_name) <- conn.private, local_script when is_list(local_script) <- phx_router.__forward__(router) do path_with_script(path, script_name ++ local_script) else _ -> nil end end defp path_with_script(path, []), do: path defp path_with_script(path, script), do: "/" <> Enum.join(script, "/") <> path end ================================================ FILE: lib/phoenix.ex ================================================ defmodule Phoenix do @moduledoc """ This is the documentation for the Phoenix project. To get started, see our [overview guides](overview.html). """ use Application @doc false def start(_type, _args) do # Warm up caches _ = Phoenix.Template.engines() _ = Phoenix.Template.format_encoder("index.html") warn_on_missing_json_library() # Configure proper system flags from Phoenix only if stacktrace_depth = Application.get_env(:phoenix, :stacktrace_depth) do :erlang.system_flag(:backtrace_depth, stacktrace_depth) end if filter = Application.get_env(:phoenix, :filter_parameters) do Application.put_env(:phoenix, :filter_parameters, Phoenix.Logger.compile_filter(filter)) end if Application.fetch_env!(:phoenix, :logger) do Phoenix.Logger.install() end children = [ # Code reloading must be serial across all Phoenix apps Phoenix.CodeReloader.Server, {DynamicSupervisor, name: Phoenix.Transports.LongPoll.Supervisor, strategy: :one_for_one} ] Supervisor.start_link(children, strategy: :one_for_one, name: Phoenix.Supervisor) end @doc """ Returns the configured JSON encoding library for Phoenix. To customize the JSON library, including the following in your `config/config.exs`: config :phoenix, :json_library, AlternativeJsonLibrary """ def json_library do Application.get_env(:phoenix, :json_library, Jason) end @doc """ Returns the `:plug_init_mode` that controls when plugs are initialized. We recommend to set it to `:runtime` in development for compilation time improvements. It must be `:compile` in production (the default). This option is passed as the `:init_mode` to `Plug.Builder.compile/3`. """ def plug_init_mode do Application.get_env(:phoenix, :plug_init_mode, :compile) end defp warn_on_missing_json_library do configured_lib = Application.get_env(:phoenix, :json_library) if configured_lib && not Code.ensure_loaded?(configured_lib) do IO.warn(""" found #{inspect(configured_lib)} in your application configuration for Phoenix JSON encoding, but module #{inspect(configured_lib)} is not available. Ensure #{inspect(configured_lib)} is listed as a dependency in mix.exs. """) end end end ================================================ FILE: mix.exs ================================================ defmodule Phoenix.MixProject do use Mix.Project if Mix.env() != :prod do for path <- :code.get_path(), Regex.match?(~r/phx_new-[\w\.\-]+\/ebin$/, List.to_string(path)) do Code.delete_path(path) end end @version "1.8.5" @scm_url "https://github.com/phoenixframework/phoenix" # If the elixir requirement is updated, we need to make the installer # use at least the minimum requirement used here. Although often the # installer is ahead of Phoenix itself. @elixir_requirement "~> 1.15" def project do [ app: :phoenix, version: @version, elixir: @elixir_requirement, deps: deps(), package: package(), consolidate_protocols: Mix.env() != :test, xref: [ exclude: [ {IEx, :started?, 0}, Ecto.Type, :ranch, :cowboy_req, Plug.Cowboy.Conn, Plug.Cowboy, :httpc, :public_key ] ], elixirc_paths: elixirc_paths(Mix.env()), name: "Phoenix", docs: &docs/0, aliases: aliases(), source_url: @scm_url, homepage_url: "https://www.phoenixframework.org", description: "Peace of mind from prototype to production", test_ignore_filters: [ &String.starts_with?(&1, "test/fixtures/"), &String.starts_with?(&1, "test/support/") ] ] end def cli do [ preferred_envs: [docs: :docs] ] end defp elixirc_paths(:docs), do: ["lib", "installer/lib"] defp elixirc_paths(_), do: ["lib"] defp extra_applications(:test), do: [:inets] defp extra_applications(_), do: [] def application do [ mod: {Phoenix, []}, extra_applications: extra_applications(Mix.env()) ++ [:logger, :eex, :crypto, :public_key], env: [ logger: true, stacktrace_depth: nil, filter_parameters: ["password"], serve_endpoints: false, gzippable_exts: ~w(.js .map .css .txt .text .html .json .svg .eot .ttf), static_compressors: [Phoenix.Digester.Gzip] ] ] end defp deps do [ {:plug, "~> 1.14"}, {:plug_crypto, "~> 1.2 or ~> 2.0"}, {:telemetry, "~> 0.4 or ~> 1.0"}, {:phoenix_pubsub, "~> 2.1"}, {:phoenix_template, "~> 1.0"}, {:websock_adapter, "~> 0.5.3"}, # TODO Drop phoenix_view as an optional dependency in Phoenix v2.0 {:phoenix_view, "~> 2.0", optional: true}, # Optional deps {:plug_cowboy, "~> 2.7", optional: true}, {:bandit, "~> 1.0", optional: true}, {:jason, "~> 1.0", optional: true}, # Docs dependencies (some for cross references) {:ex_doc, "~> 0.38", only: :docs}, {:ecto, "~> 3.0", only: :docs}, {:ecto_sql, "~> 3.10", only: :docs}, {:gettext, "~> 1.0", only: :docs}, {:telemetry_poller, "~> 1.0", only: :docs}, {:telemetry_metrics, "~> 1.0", only: :docs}, {:makeup_elixir, "~> 1.0.1 or ~> 1.1", only: :docs}, {:makeup_eex, "~> 2.0", only: :docs}, {:makeup_syntect, "~> 0.1.0", only: :docs}, # Test dependencies {:phoenix_html, "~> 4.0", only: [:docs, :test]}, {:phx_new, path: "./installer", only: [:docs, :test]}, {:mint, "~> 1.4", only: :test}, {:mint_web_socket, "~> 1.0.0", only: :test}, # Dev dependencies {:esbuild, "~> 0.8", only: :dev} ] end defp package do [ maintainers: ["Chris McCord", "José Valim", "Gary Rennie", "Jason Stiebs"], licenses: ["MIT"], links: %{ "GitHub" => @scm_url, "Changelog" => "https://hexdocs.pm/phoenix/changelog.html" }, files: ~w( assets/js lib priv usage-rules CHANGELOG.md LICENSE.md mix.exs package.json README.md .formatter.exs installer/templates/phx_web/components/core_components.ex ) ] end defp docs do [ search: [ %{ name: "Latest", help: "Search latest versions of Plug, Phoenix, Phoenix.{HTML, LiveView, PubSub, Template}", packages: [ :plug, :phoenix, :phoenix_html, :phoenix_live_view, :phoenix_pubsub, :phoenix_template ] }, %{ name: "Current version", help: "Search only this project" } ], source_ref: "v#{@version}", main: "overview", logo: "logo.png", extra_section: "GUIDES", assets: %{"guides/assets" => "assets"}, formatters: ["html", "epub"], groups_for_modules: groups_for_modules(), extras: extras(), groups_for_extras: groups_for_extras(), groups_for_docs: [ Reflection: &(&1[:type] == :reflection) ], skip_undefined_reference_warnings_on: ["CHANGELOG.md"] ] end defp extras do [ "guides/introduction/overview.md", "guides/introduction/installation.md", "guides/introduction/up_and_running.md", "guides/introduction/community.md", "guides/introduction/packages_glossary.md", "guides/directory_structure.md", "guides/request_lifecycle.md", "guides/plug.md", "guides/routing.md", "guides/controllers.md", "guides/components.md", "guides/ecto.md", "guides/json_and_apis.md", "guides/live_view.md", "guides/asset_management.md", "guides/telemetry.md", "guides/security.md", "guides/authn_authz/authn_authz.md", "guides/authn_authz/mix_phx_gen_auth.md", "guides/authn_authz/scopes.md", "guides/authn_authz/api_authentication.md", "guides/data_modelling/contexts.md", "guides/data_modelling/your_first_context.md", "guides/data_modelling/in_context_relationships.md", "guides/data_modelling/cross_context_boundaries.md", "guides/data_modelling/more_examples.md", "guides/data_modelling/faq.md", "guides/real_time/channels.md", "guides/real_time/presence.md", "guides/testing/testing.md", "guides/testing/testing_contexts.md", "guides/testing/testing_controllers.md", "guides/testing/testing_channels.md", "guides/deployment/deployment.md", "guides/deployment/releases.md", "guides/deployment/fly.md", "guides/deployment/gigalixir.md", "guides/deployment/heroku.md", "guides/howto/custom_error_pages.md", "guides/howto/file_uploads.md", "guides/howto/swapping_databases.md", "guides/howto/using_ssl.md", "guides/howto/writing_a_channels_client.md", "guides/cheatsheets/router.cheatmd", "CHANGELOG.md", "JS Documentation": [url: "js/index.html"] ] end defp groups_for_extras do [ Introduction: ~r/guides\/introduction\/.?/, "Core Concepts": ~r/guides\/[^\/]+\.md/, "Data Modelling": ~r/guides\/data_modelling\/.?/, "Authn and Authz": ~r/guides\/authn_authz\/.?/, "Real-time": ~r/guides\/real_time\/.?/, Testing: ~r/guides\/testing\/.?/, Deployment: ~r/guides\/deployment\/.?/, Cheatsheets: ~r/guides\/cheatsheets\/.?/, "How-to's": ~r/guides\/howto\/.?/ ] end defp groups_for_modules do # Ungrouped Modules: # # Phoenix # Phoenix.Channel # Phoenix.Controller # Phoenix.Endpoint # Phoenix.Naming # Phoenix.Logger # Phoenix.Param # Phoenix.Presence # Phoenix.Router # Phoenix.Socket # Phoenix.Token # Phoenix.VerifiedRoutes [ Testing: [ Phoenix.ChannelTest, Phoenix.ConnTest ], "Adapters and Plugs": [ Phoenix.CodeReloader, Phoenix.Endpoint.Cowboy2Adapter, Phoenix.Endpoint.SyncCodeReloadPlug ], Digester: [ Phoenix.Digester.Compressor, Phoenix.Digester.Gzip ], Socket: [ Phoenix.Socket.Broadcast, Phoenix.Socket.Message, Phoenix.Socket.Reply, Phoenix.Socket.Serializer, Phoenix.Socket.Transport ] ] end defp aliases do [ docs: ["docs", &generate_js_docs/1], "assets.build": ["esbuild module", "esbuild cdn", "esbuild cdn_min", "esbuild main"], "assets.watch": "esbuild module --watch", "archive.build": &raise_on_archive_build/1, # copy core_components before compiling / publishing compile: [©_core_components/1, "compile"], "hex.publish": [©_core_components/1, "hex.publish"] ] end defp generate_js_docs(_) do Mix.Task.run("app.start") {_, 0} = System.cmd("npm", ["install"], into: IO.stream()) {_, 0} = System.cmd("npm", ["run", "docs"], into: IO.stream()) end defp raise_on_archive_build(_) do Mix.raise(""" You are trying to install "phoenix" as an archive, which is not supported. \ You probably meant to install "phx_new" instead """) end defp copy_core_components(_) do source = Path.join(__DIR__, "installer/templates/phx_web/components/core_components.ex.eex") destination_dir = Path.join([__DIR__, "priv", "templates", "phx.gen.live"]) destination = Path.join(destination_dir, "core_components.ex.eex") File.cp!(source, destination) end end ================================================ FILE: package.json ================================================ { "name": "phoenix", "version": "1.8.5", "description": "The official JavaScript client for the Phoenix web framework.", "license": "MIT", "module": "./priv/static/phoenix.mjs", "main": "./priv/static/phoenix.cjs.js", "unpkg": "./priv/static/phoenix.min.js", "jsdelivr": "./priv/static/phoenix.min.js", "exports": { "import": "./priv/static/phoenix.mjs", "require": "./priv/static/phoenix.cjs.js" }, "repository": { "type": "git", "url": "git://github.com/phoenixframework/phoenix.git" }, "author": "Chris McCord (https://www.phoenixframework.org)", "files": [ "README.md", "LICENSE.md", "package.json", "priv/static/*", "assets/js/phoenix/*" ], "devDependencies": { "@babel/cli": "7.28.6", "@babel/core": "7.29.0", "@babel/preset-env": "7.29.0", "@eslint/js": "^10.0.1", "@stylistic/eslint-plugin": "^5.0.0", "documentation": "^14.0.3", "eslint": "10.0.2", "eslint-plugin-jest": "29.15.0", "jest": "^30.0.0", "jest-environment-jsdom": "^30.0.0", "jsdom": "^28.1.0", "mock-socket": "^9.3.1" }, "scripts": { "test": "jest", "test.coverage": "jest --coverage", "test.watch": "jest --watch", "docs": "documentation build assets/js/phoenix/index.js -f html -o doc/js" } } ================================================ FILE: priv/static/phoenix.cjs.js ================================================ var __defProp = Object.defineProperty; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; var __hasOwnProp = Object.prototype.hasOwnProperty; var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true }); }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); } return to; }; var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); // js/phoenix/index.js var phoenix_exports = {}; __export(phoenix_exports, { Channel: () => Channel, LongPoll: () => LongPoll, Presence: () => Presence, Serializer: () => serializer_default, Socket: () => Socket }); module.exports = __toCommonJS(phoenix_exports); // js/phoenix/utils.js var closure = (value) => { if (typeof value === "function") { return value; } else { let closure2 = function() { return value; }; return closure2; } }; // js/phoenix/constants.js var globalSelf = typeof self !== "undefined" ? self : null; var phxWindow = typeof window !== "undefined" ? window : null; var global = globalSelf || phxWindow || globalThis; var DEFAULT_VSN = "2.0.0"; var SOCKET_STATES = { connecting: 0, open: 1, closing: 2, closed: 3 }; var DEFAULT_TIMEOUT = 1e4; var WS_CLOSE_NORMAL = 1e3; var CHANNEL_STATES = { closed: "closed", errored: "errored", joined: "joined", joining: "joining", leaving: "leaving" }; var CHANNEL_EVENTS = { close: "phx_close", error: "phx_error", join: "phx_join", reply: "phx_reply", leave: "phx_leave" }; var TRANSPORTS = { longpoll: "longpoll", websocket: "websocket" }; var XHR_STATES = { complete: 4 }; var AUTH_TOKEN_PREFIX = "base64url.bearer.phx."; // js/phoenix/push.js var Push = class { constructor(channel, event, payload, timeout) { this.channel = channel; this.event = event; this.payload = payload || function() { return {}; }; this.receivedResp = null; this.timeout = timeout; this.timeoutTimer = null; this.recHooks = []; this.sent = false; } /** * * @param {number} timeout */ resend(timeout) { this.timeout = timeout; this.reset(); this.send(); } /** * */ send() { if (this.hasReceived("timeout")) { return; } this.startTimeout(); this.sent = true; this.channel.socket.push({ topic: this.channel.topic, event: this.event, payload: this.payload(), ref: this.ref, join_ref: this.channel.joinRef() }); } /** * * @param {*} status * @param {*} callback */ receive(status, callback) { if (this.hasReceived(status)) { callback(this.receivedResp.response); } this.recHooks.push({ status, callback }); return this; } /** * @private */ reset() { this.cancelRefEvent(); this.ref = null; this.refEvent = null; this.receivedResp = null; this.sent = false; } /** * @private */ matchReceive({ status, response, _ref }) { this.recHooks.filter((h) => h.status === status).forEach((h) => h.callback(response)); } /** * @private */ cancelRefEvent() { if (!this.refEvent) { return; } this.channel.off(this.refEvent); } /** * @private */ cancelTimeout() { clearTimeout(this.timeoutTimer); this.timeoutTimer = null; } /** * @private */ startTimeout() { if (this.timeoutTimer) { this.cancelTimeout(); } this.ref = this.channel.socket.makeRef(); this.refEvent = this.channel.replyEventName(this.ref); this.channel.on(this.refEvent, (payload) => { this.cancelRefEvent(); this.cancelTimeout(); this.receivedResp = payload; this.matchReceive(payload); }); this.timeoutTimer = setTimeout(() => { this.trigger("timeout", {}); }, this.timeout); } /** * @private */ hasReceived(status) { return this.receivedResp && this.receivedResp.status === status; } /** * @private */ trigger(status, response) { this.channel.trigger(this.refEvent, { status, response }); } }; // js/phoenix/timer.js var Timer = class { constructor(callback, timerCalc) { this.callback = callback; this.timerCalc = timerCalc; this.timer = null; this.tries = 0; } reset() { this.tries = 0; clearTimeout(this.timer); } /** * Cancels any previous scheduleTimeout and schedules callback */ scheduleTimeout() { clearTimeout(this.timer); this.timer = setTimeout(() => { this.tries = this.tries + 1; this.callback(); }, this.timerCalc(this.tries + 1)); } }; // js/phoenix/channel.js var Channel = class { constructor(topic, params, socket) { this.state = CHANNEL_STATES.closed; this.topic = topic; this.params = closure(params || {}); this.socket = socket; this.bindings = []; this.bindingRef = 0; this.timeout = this.socket.timeout; this.joinedOnce = false; this.joinPush = new Push(this, CHANNEL_EVENTS.join, this.params, this.timeout); this.pushBuffer = []; this.stateChangeRefs = []; this.rejoinTimer = new Timer(() => { if (this.socket.isConnected()) { this.rejoin(); } }, this.socket.rejoinAfterMs); this.stateChangeRefs.push(this.socket.onError(() => this.rejoinTimer.reset())); this.stateChangeRefs.push( this.socket.onOpen(() => { this.rejoinTimer.reset(); if (this.isErrored()) { this.rejoin(); } }) ); this.joinPush.receive("ok", () => { this.state = CHANNEL_STATES.joined; this.rejoinTimer.reset(); this.pushBuffer.forEach((pushEvent) => pushEvent.send()); this.pushBuffer = []; }); this.joinPush.receive("error", () => { this.state = CHANNEL_STATES.errored; if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.onClose(() => { this.rejoinTimer.reset(); if (this.socket.hasLogger()) this.socket.log("channel", `close ${this.topic} ${this.joinRef()}`); this.state = CHANNEL_STATES.closed; this.socket.remove(this); }); this.onError((reason) => { if (this.socket.hasLogger()) this.socket.log("channel", `error ${this.topic}`, reason); if (this.isJoining()) { this.joinPush.reset(); } this.state = CHANNEL_STATES.errored; if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.joinPush.receive("timeout", () => { if (this.socket.hasLogger()) this.socket.log("channel", `timeout ${this.topic} (${this.joinRef()})`, this.joinPush.timeout); let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), this.timeout); leavePush.send(); this.state = CHANNEL_STATES.errored; this.joinPush.reset(); if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.on(CHANNEL_EVENTS.reply, (payload, ref) => { this.trigger(this.replyEventName(ref), payload); }); } /** * Join the channel * @param {integer} timeout * @returns {Push} */ join(timeout = this.timeout) { if (this.joinedOnce) { throw new Error("tried to join multiple times. 'join' can only be called a single time per channel instance"); } else { this.timeout = timeout; this.joinedOnce = true; this.rejoin(); return this.joinPush; } } /** * Hook into channel close * @param {Function} callback */ onClose(callback) { this.on(CHANNEL_EVENTS.close, callback); } /** * Hook into channel errors * @param {Function} callback */ onError(callback) { return this.on(CHANNEL_EVENTS.error, (reason) => callback(reason)); } /** * Subscribes on channel events * * Subscription returns a ref counter, which can be used later to * unsubscribe the exact event listener * * @example * const ref1 = channel.on("event", do_stuff) * const ref2 = channel.on("event", do_other_stuff) * channel.off("event", ref1) * // Since unsubscription, do_stuff won't fire, * // while do_other_stuff will keep firing on the "event" * * @param {string} event * @param {Function} callback * @returns {integer} ref */ on(event, callback) { let ref = this.bindingRef++; this.bindings.push({ event, ref, callback }); return ref; } /** * Unsubscribes off of channel events * * Use the ref returned from a channel.on() to unsubscribe one * handler, or pass nothing for the ref to unsubscribe all * handlers for the given event. * * @example * // Unsubscribe the do_stuff handler * const ref1 = channel.on("event", do_stuff) * channel.off("event", ref1) * * // Unsubscribe all handlers from event * channel.off("event") * * @param {string} event * @param {integer} ref */ off(event, ref) { this.bindings = this.bindings.filter((bind) => { return !(bind.event === event && (typeof ref === "undefined" || ref === bind.ref)); }); } /** * @private */ canPush() { return this.socket.isConnected() && this.isJoined(); } /** * Sends a message `event` to phoenix with the payload `payload`. * Phoenix receives this in the `handle_in(event, payload, socket)` * function. if phoenix replies or it times out (default 10000ms), * then optionally the reply can be received. * * @example * channel.push("event") * .receive("ok", payload => console.log("phoenix replied:", payload)) * .receive("error", err => console.log("phoenix errored", err)) * .receive("timeout", () => console.log("timed out pushing")) * @param {string} event * @param {Object} payload * @param {number} [timeout] * @returns {Push} */ push(event, payload, timeout = this.timeout) { payload = payload || {}; if (!this.joinedOnce) { throw new Error(`tried to push '${event}' to '${this.topic}' before joining. Use channel.join() before pushing events`); } let pushEvent = new Push(this, event, function() { return payload; }, timeout); if (this.canPush()) { pushEvent.send(); } else { pushEvent.startTimeout(); this.pushBuffer.push(pushEvent); } return pushEvent; } /** Leaves the channel * * Unsubscribes from server events, and * instructs channel to terminate on server * * Triggers onClose() hooks * * To receive leave acknowledgements, use the `receive` * hook to bind to the server ack, ie: * * @example * channel.leave().receive("ok", () => alert("left!") ) * * @param {integer} timeout * @returns {Push} */ leave(timeout = this.timeout) { this.rejoinTimer.reset(); this.joinPush.cancelTimeout(); this.state = CHANNEL_STATES.leaving; let onClose = () => { if (this.socket.hasLogger()) this.socket.log("channel", `leave ${this.topic}`); this.trigger(CHANNEL_EVENTS.close, "leave"); }; let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), timeout); leavePush.receive("ok", () => onClose()).receive("timeout", () => onClose()); leavePush.send(); if (!this.canPush()) { leavePush.trigger("ok", {}); } return leavePush; } /** * Overridable message hook * * Receives all events for specialized message handling * before dispatching to the channel callbacks. * * Must return the payload, modified or unmodified * @param {string} event * @param {Object} payload * @param {integer} ref * @returns {Object} */ onMessage(_event, payload, _ref) { return payload; } /** * @private */ isMember(topic, event, payload, joinRef) { if (this.topic !== topic) { return false; } if (joinRef && joinRef !== this.joinRef()) { if (this.socket.hasLogger()) this.socket.log("channel", "dropping outdated message", { topic, event, payload, joinRef }); return false; } else { return true; } } /** * @private */ joinRef() { return this.joinPush.ref; } /** * @private */ rejoin(timeout = this.timeout) { if (this.isLeaving()) { return; } this.socket.leaveOpenTopic(this.topic); this.state = CHANNEL_STATES.joining; this.joinPush.resend(timeout); } /** * @private */ trigger(event, payload, ref, joinRef) { let handledPayload = this.onMessage(event, payload, ref, joinRef); if (payload && !handledPayload) { throw new Error("channel onMessage callbacks must return the payload, modified or unmodified"); } let eventBindings = this.bindings.filter((bind) => bind.event === event); for (let i = 0; i < eventBindings.length; i++) { let bind = eventBindings[i]; bind.callback(handledPayload, ref, joinRef || this.joinRef()); } } /** * @private */ replyEventName(ref) { return `chan_reply_${ref}`; } /** * @private */ isClosed() { return this.state === CHANNEL_STATES.closed; } /** * @private */ isErrored() { return this.state === CHANNEL_STATES.errored; } /** * @private */ isJoined() { return this.state === CHANNEL_STATES.joined; } /** * @private */ isJoining() { return this.state === CHANNEL_STATES.joining; } /** * @private */ isLeaving() { return this.state === CHANNEL_STATES.leaving; } }; // js/phoenix/ajax.js var Ajax = class { static request(method, endPoint, headers, body, timeout, ontimeout, callback) { if (global.XDomainRequest) { let req = new global.XDomainRequest(); return this.xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback); } else if (global.XMLHttpRequest) { let req = new global.XMLHttpRequest(); return this.xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback); } else if (global.fetch && global.AbortController) { return this.fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback); } else { throw new Error("No suitable XMLHttpRequest implementation found"); } } static fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback) { let options = { method, headers, body }; let controller = null; if (timeout) { controller = new AbortController(); const _timeoutId = setTimeout(() => controller.abort(), timeout); options.signal = controller.signal; } global.fetch(endPoint, options).then((response) => response.text()).then((data) => this.parseJSON(data)).then((data) => callback && callback(data)).catch((err) => { if (err.name === "AbortError" && ontimeout) { ontimeout(); } else { callback && callback(null); } }); return controller; } static xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback) { req.timeout = timeout; req.open(method, endPoint); req.onload = () => { let response = this.parseJSON(req.responseText); callback && callback(response); }; if (ontimeout) { req.ontimeout = ontimeout; } req.onprogress = () => { }; req.send(body); return req; } static xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback) { req.open(method, endPoint, true); req.timeout = timeout; for (let [key, value] of Object.entries(headers)) { req.setRequestHeader(key, value); } req.onerror = () => callback && callback(null); req.onreadystatechange = () => { if (req.readyState === XHR_STATES.complete && callback) { let response = this.parseJSON(req.responseText); callback(response); } }; if (ontimeout) { req.ontimeout = ontimeout; } req.send(body); return req; } static parseJSON(resp) { if (!resp || resp === "") { return null; } try { return JSON.parse(resp); } catch { console && console.log("failed to parse JSON response", resp); return null; } } static serialize(obj, parentKey) { let queryStr = []; for (var key in obj) { if (!Object.prototype.hasOwnProperty.call(obj, key)) { continue; } let paramKey = parentKey ? `${parentKey}[${key}]` : key; let paramVal = obj[key]; if (typeof paramVal === "object") { queryStr.push(this.serialize(paramVal, paramKey)); } else { queryStr.push(encodeURIComponent(paramKey) + "=" + encodeURIComponent(paramVal)); } } return queryStr.join("&"); } static appendParams(url, params) { if (Object.keys(params).length === 0) { return url; } let prefix = url.match(/\?/) ? "&" : "?"; return `${url}${prefix}${this.serialize(params)}`; } }; // js/phoenix/longpoll.js var arrayBufferToBase64 = (buffer) => { let binary = ""; let bytes = new Uint8Array(buffer); let len = bytes.byteLength; for (let i = 0; i < len; i++) { binary += String.fromCharCode(bytes[i]); } return btoa(binary); }; var LongPoll = class { constructor(endPoint, protocols) { if (protocols && protocols.length === 2 && protocols[1].startsWith(AUTH_TOKEN_PREFIX)) { this.authToken = atob(protocols[1].slice(AUTH_TOKEN_PREFIX.length)); } this.endPoint = null; this.token = null; this.skipHeartbeat = true; this.reqs = /* @__PURE__ */ new Set(); this.awaitingBatchAck = false; this.currentBatch = null; this.currentBatchTimer = null; this.batchBuffer = []; this.onopen = function() { }; this.onerror = function() { }; this.onmessage = function() { }; this.onclose = function() { }; this.pollEndpoint = this.normalizeEndpoint(endPoint); this.readyState = SOCKET_STATES.connecting; setTimeout(() => this.poll(), 0); } normalizeEndpoint(endPoint) { return endPoint.replace("ws://", "http://").replace("wss://", "https://").replace(new RegExp("(.*)/" + TRANSPORTS.websocket), "$1/" + TRANSPORTS.longpoll); } endpointURL() { return Ajax.appendParams(this.pollEndpoint, { token: this.token }); } closeAndRetry(code, reason, wasClean) { this.close(code, reason, wasClean); this.readyState = SOCKET_STATES.connecting; } ontimeout() { this.onerror("timeout"); this.closeAndRetry(1005, "timeout", false); } isActive() { return this.readyState === SOCKET_STATES.open || this.readyState === SOCKET_STATES.connecting; } poll() { const headers = { "Accept": "application/json" }; if (this.authToken) { headers["X-Phoenix-AuthToken"] = this.authToken; } this.ajax("GET", headers, null, () => this.ontimeout(), (resp) => { if (resp) { var { status, token, messages } = resp; if (status === 410 && this.token !== null) { this.onerror(410); this.closeAndRetry(3410, "session_gone", false); return; } this.token = token; } else { status = 0; } switch (status) { case 200: messages.forEach((msg) => { setTimeout(() => this.onmessage({ data: msg }), 0); }); this.poll(); break; case 204: this.poll(); break; case 410: this.readyState = SOCKET_STATES.open; this.onopen({}); this.poll(); break; case 403: this.onerror(403); this.close(1008, "forbidden", false); break; case 0: case 500: this.onerror(500); this.closeAndRetry(1011, "internal server error", 500); break; default: throw new Error(`unhandled poll status ${status}`); } }); } // we collect all pushes within the current event loop by // setTimeout 0, which optimizes back-to-back procedural // pushes against an empty buffer send(body) { if (typeof body !== "string") { body = arrayBufferToBase64(body); } if (this.currentBatch) { this.currentBatch.push(body); } else if (this.awaitingBatchAck) { this.batchBuffer.push(body); } else { this.currentBatch = [body]; this.currentBatchTimer = setTimeout(() => { this.batchSend(this.currentBatch); this.currentBatch = null; }, 0); } } batchSend(messages) { this.awaitingBatchAck = true; this.ajax("POST", { "Content-Type": "application/x-ndjson" }, messages.join("\n"), () => this.onerror("timeout"), (resp) => { this.awaitingBatchAck = false; if (!resp || resp.status !== 200) { this.onerror(resp && resp.status); this.closeAndRetry(1011, "internal server error", false); } else if (this.batchBuffer.length > 0) { this.batchSend(this.batchBuffer); this.batchBuffer = []; } }); } close(code, reason, wasClean) { for (let req of this.reqs) { req.abort(); } this.readyState = SOCKET_STATES.closed; let opts = Object.assign({ code: 1e3, reason: void 0, wasClean: true }, { code, reason, wasClean }); this.batchBuffer = []; clearTimeout(this.currentBatchTimer); this.currentBatchTimer = null; if (typeof CloseEvent !== "undefined") { this.onclose(new CloseEvent("close", opts)); } else { this.onclose(opts); } } ajax(method, headers, body, onCallerTimeout, callback) { let req; let ontimeout = () => { this.reqs.delete(req); onCallerTimeout(); }; req = Ajax.request(method, this.endpointURL(), headers, body, this.timeout, ontimeout, (resp) => { this.reqs.delete(req); if (this.isActive()) { callback(resp); } }); this.reqs.add(req); } }; // js/phoenix/presence.js var Presence = class _Presence { constructor(channel, opts = {}) { let events = opts.events || { state: "presence_state", diff: "presence_diff" }; this.state = {}; this.pendingDiffs = []; this.channel = channel; this.joinRef = null; this.caller = { onJoin: function() { }, onLeave: function() { }, onSync: function() { } }; this.channel.on(events.state, (newState) => { let { onJoin, onLeave, onSync } = this.caller; this.joinRef = this.channel.joinRef(); this.state = _Presence.syncState(this.state, newState, onJoin, onLeave); this.pendingDiffs.forEach((diff) => { this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave); }); this.pendingDiffs = []; onSync(); }); this.channel.on(events.diff, (diff) => { let { onJoin, onLeave, onSync } = this.caller; if (this.inPendingSyncState()) { this.pendingDiffs.push(diff); } else { this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave); onSync(); } }); } onJoin(callback) { this.caller.onJoin = callback; } onLeave(callback) { this.caller.onLeave = callback; } onSync(callback) { this.caller.onSync = callback; } list(by) { return _Presence.list(this.state, by); } inPendingSyncState() { return !this.joinRef || this.joinRef !== this.channel.joinRef(); } // lower-level public static API /** * Used to sync the list of presences on the server * with the client's state. An optional `onJoin` and `onLeave` callback can * be provided to react to changes in the client's local presences across * disconnects and reconnects with the server. * * @returns {Presence} */ static syncState(currentState, newState, onJoin, onLeave) { let state = this.clone(currentState); let joins = {}; let leaves = {}; this.map(state, (key, presence) => { if (!newState[key]) { leaves[key] = presence; } }); this.map(newState, (key, newPresence) => { let currentPresence = state[key]; if (currentPresence) { let newRefs = newPresence.metas.map((m) => m.phx_ref); let curRefs = currentPresence.metas.map((m) => m.phx_ref); let joinedMetas = newPresence.metas.filter((m) => curRefs.indexOf(m.phx_ref) < 0); let leftMetas = currentPresence.metas.filter((m) => newRefs.indexOf(m.phx_ref) < 0); if (joinedMetas.length > 0) { joins[key] = newPresence; joins[key].metas = joinedMetas; } if (leftMetas.length > 0) { leaves[key] = this.clone(currentPresence); leaves[key].metas = leftMetas; } } else { joins[key] = newPresence; } }); return this.syncDiff(state, { joins, leaves }, onJoin, onLeave); } /** * * Used to sync a diff of presence join and leave * events from the server, as they happen. Like `syncState`, `syncDiff` * accepts optional `onJoin` and `onLeave` callbacks to react to a user * joining or leaving from a device. * * @returns {Presence} */ static syncDiff(state, diff, onJoin, onLeave) { let { joins, leaves } = this.clone(diff); if (!onJoin) { onJoin = function() { }; } if (!onLeave) { onLeave = function() { }; } this.map(joins, (key, newPresence) => { let currentPresence = state[key]; state[key] = this.clone(newPresence); if (currentPresence) { let joinedRefs = state[key].metas.map((m) => m.phx_ref); let curMetas = currentPresence.metas.filter((m) => joinedRefs.indexOf(m.phx_ref) < 0); state[key].metas.unshift(...curMetas); } onJoin(key, currentPresence, newPresence); }); this.map(leaves, (key, leftPresence) => { let currentPresence = state[key]; if (!currentPresence) { return; } let refsToRemove = leftPresence.metas.map((m) => m.phx_ref); currentPresence.metas = currentPresence.metas.filter((p) => { return refsToRemove.indexOf(p.phx_ref) < 0; }); onLeave(key, currentPresence, leftPresence); if (currentPresence.metas.length === 0) { delete state[key]; } }); return state; } /** * Returns the array of presences, with selected metadata. * * @param {Object} presences * @param {Function} chooser * * @returns {Presence} */ static list(presences, chooser) { if (!chooser) { chooser = function(key, pres) { return pres; }; } return this.map(presences, (key, presence) => { return chooser(key, presence); }); } // private static map(obj, func) { return Object.getOwnPropertyNames(obj).map((key) => func(key, obj[key])); } static clone(obj) { return JSON.parse(JSON.stringify(obj)); } }; // js/phoenix/serializer.js var serializer_default = { HEADER_LENGTH: 1, META_LENGTH: 4, KINDS: { push: 0, reply: 1, broadcast: 2 }, encode(msg, callback) { if (msg.payload.constructor === ArrayBuffer) { return callback(this.binaryEncode(msg)); } else { let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload]; return callback(JSON.stringify(payload)); } }, decode(rawPayload, callback) { if (rawPayload.constructor === ArrayBuffer) { return callback(this.binaryDecode(rawPayload)); } else { let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload); return callback({ join_ref, ref, topic, event, payload }); } }, // private binaryEncode(message) { let { join_ref, ref, event, topic, payload } = message; let metaLength = this.META_LENGTH + join_ref.length + ref.length + topic.length + event.length; let header = new ArrayBuffer(this.HEADER_LENGTH + metaLength); let view = new DataView(header); let offset = 0; view.setUint8(offset++, this.KINDS.push); view.setUint8(offset++, join_ref.length); view.setUint8(offset++, ref.length); view.setUint8(offset++, topic.length); view.setUint8(offset++, event.length); Array.from(join_ref, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(ref, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(topic, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(event, (char) => view.setUint8(offset++, char.charCodeAt(0))); var combined = new Uint8Array(header.byteLength + payload.byteLength); combined.set(new Uint8Array(header), 0); combined.set(new Uint8Array(payload), header.byteLength); return combined.buffer; }, binaryDecode(buffer) { let view = new DataView(buffer); let kind = view.getUint8(0); let decoder = new TextDecoder(); switch (kind) { case this.KINDS.push: return this.decodePush(buffer, view, decoder); case this.KINDS.reply: return this.decodeReply(buffer, view, decoder); case this.KINDS.broadcast: return this.decodeBroadcast(buffer, view, decoder); } }, decodePush(buffer, view, decoder) { let joinRefSize = view.getUint8(1); let topicSize = view.getUint8(2); let eventSize = view.getUint8(3); let offset = this.HEADER_LENGTH + this.META_LENGTH - 1; let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)); offset = offset + joinRefSize; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); return { join_ref: joinRef, ref: null, topic, event, payload: data }; }, decodeReply(buffer, view, decoder) { let joinRefSize = view.getUint8(1); let refSize = view.getUint8(2); let topicSize = view.getUint8(3); let eventSize = view.getUint8(4); let offset = this.HEADER_LENGTH + this.META_LENGTH; let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)); offset = offset + joinRefSize; let ref = decoder.decode(buffer.slice(offset, offset + refSize)); offset = offset + refSize; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); let payload = { status: event, response: data }; return { join_ref: joinRef, ref, topic, event: CHANNEL_EVENTS.reply, payload }; }, decodeBroadcast(buffer, view, decoder) { let topicSize = view.getUint8(1); let eventSize = view.getUint8(2); let offset = this.HEADER_LENGTH + 2; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); return { join_ref: null, ref: null, topic, event, payload: data }; } }; // js/phoenix/socket.js var Socket = class { constructor(endPoint, opts = {}) { this.stateChangeCallbacks = { open: [], close: [], error: [], message: [] }; this.channels = []; this.sendBuffer = []; this.ref = 0; this.fallbackRef = null; this.timeout = opts.timeout || DEFAULT_TIMEOUT; this.transport = opts.transport || global.WebSocket || LongPoll; this.primaryPassedHealthCheck = false; this.longPollFallbackMs = opts.longPollFallbackMs; this.fallbackTimer = null; this.sessionStore = opts.sessionStorage || global && global.sessionStorage; this.establishedConnections = 0; this.defaultEncoder = serializer_default.encode.bind(serializer_default); this.defaultDecoder = serializer_default.decode.bind(serializer_default); this.closeWasClean = true; this.disconnecting = false; this.binaryType = opts.binaryType || "arraybuffer"; this.connectClock = 1; this.pageHidden = false; if (this.transport !== LongPoll) { this.encode = opts.encode || this.defaultEncoder; this.decode = opts.decode || this.defaultDecoder; } else { this.encode = this.defaultEncoder; this.decode = this.defaultDecoder; } let awaitingConnectionOnPageShow = null; if (phxWindow && phxWindow.addEventListener) { phxWindow.addEventListener("pagehide", (_e) => { if (this.conn) { this.disconnect(); awaitingConnectionOnPageShow = this.connectClock; } }); phxWindow.addEventListener("pageshow", (_e) => { if (awaitingConnectionOnPageShow === this.connectClock) { awaitingConnectionOnPageShow = null; this.connect(); } }); phxWindow.addEventListener("visibilitychange", () => { if (document.visibilityState === "hidden") { this.pageHidden = true; } else { this.pageHidden = false; if (!this.isConnected() && !this.closeWasClean) { this.teardown(() => this.connect()); } } }); } this.heartbeatIntervalMs = opts.heartbeatIntervalMs || 3e4; this.rejoinAfterMs = (tries) => { if (opts.rejoinAfterMs) { return opts.rejoinAfterMs(tries); } else { return [1e3, 2e3, 5e3][tries - 1] || 1e4; } }; this.reconnectAfterMs = (tries) => { if (opts.reconnectAfterMs) { return opts.reconnectAfterMs(tries); } else { return [10, 50, 100, 150, 200, 250, 500, 1e3, 2e3][tries - 1] || 5e3; } }; this.logger = opts.logger || null; if (!this.logger && opts.debug) { this.logger = (kind, msg, data) => { console.log(`${kind}: ${msg}`, data); }; } this.longpollerTimeout = opts.longpollerTimeout || 2e4; this.params = closure(opts.params || {}); this.endPoint = `${endPoint}/${TRANSPORTS.websocket}`; this.vsn = opts.vsn || DEFAULT_VSN; this.heartbeatTimeoutTimer = null; this.heartbeatTimer = null; this.pendingHeartbeatRef = null; this.reconnectTimer = new Timer(() => { if (this.pageHidden) { this.log("Not reconnecting as page is hidden!"); this.teardown(); return; } this.teardown(() => this.connect()); }, this.reconnectAfterMs); this.authToken = opts.authToken; } /** * Returns the LongPoll transport reference */ getLongPollTransport() { return LongPoll; } /** * Disconnects and replaces the active transport * * @param {Function} newTransport - The new transport class to instantiate * */ replaceTransport(newTransport) { this.connectClock++; this.closeWasClean = true; clearTimeout(this.fallbackTimer); this.reconnectTimer.reset(); if (this.conn) { this.conn.close(); this.conn = null; } this.transport = newTransport; } /** * Returns the socket protocol * * @returns {string} */ protocol() { return location.protocol.match(/^https/) ? "wss" : "ws"; } /** * The fully qualified socket url * * @returns {string} */ endPointURL() { let uri = Ajax.appendParams( Ajax.appendParams(this.endPoint, this.params()), { vsn: this.vsn } ); if (uri.charAt(0) !== "/") { return uri; } if (uri.charAt(1) === "/") { return `${this.protocol()}:${uri}`; } return `${this.protocol()}://${location.host}${uri}`; } /** * Disconnects the socket * * See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes for valid status codes. * * @param {Function} callback - Optional callback which is called after socket is disconnected. * @param {integer} code - A status code for disconnection (Optional). * @param {string} reason - A textual description of the reason to disconnect. (Optional) */ disconnect(callback, code, reason) { this.connectClock++; this.disconnecting = true; this.closeWasClean = true; clearTimeout(this.fallbackTimer); this.reconnectTimer.reset(); this.teardown(() => { this.disconnecting = false; callback && callback(); }, code, reason); } /** * * @param {Object} params - The params to send when connecting, for example `{user_id: userToken}` * * Passing params to connect is deprecated; pass them in the Socket constructor instead: * `new Socket("/socket", {params: {user_id: userToken}})`. */ connect(params) { if (params) { console && console.log("passing params to connect is deprecated. Instead pass :params to the Socket constructor"); this.params = closure(params); } if (this.conn && !this.disconnecting) { return; } if (this.longPollFallbackMs && this.transport !== LongPoll) { this.connectWithFallback(LongPoll, this.longPollFallbackMs); } else { this.transportConnect(); } } /** * Logs the message. Override `this.logger` for specialized logging. noops by default * @param {string} kind * @param {string} msg * @param {Object} data */ log(kind, msg, data) { this.logger && this.logger(kind, msg, data); } /** * Returns true if a logger has been set on this socket. */ hasLogger() { return this.logger !== null; } /** * Registers callbacks for connection open events * * @example socket.onOpen(function(){ console.info("the socket was opened") }) * * @param {Function} callback */ onOpen(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.open.push([ref, callback]); return ref; } /** * Registers callbacks for connection close events * @param {Function} callback */ onClose(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.close.push([ref, callback]); return ref; } /** * Registers callbacks for connection error events * * @example socket.onError(function(error){ alert("An error occurred") }) * * @param {Function} callback */ onError(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.error.push([ref, callback]); return ref; } /** * Registers callbacks for connection message events * @param {Function} callback */ onMessage(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.message.push([ref, callback]); return ref; } /** * Pings the server and invokes the callback with the RTT in milliseconds * @param {Function} callback * * Returns true if the ping was pushed or false if unable to be pushed. */ ping(callback) { if (!this.isConnected()) { return false; } let ref = this.makeRef(); let startTime = Date.now(); this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref }); let onMsgRef = this.onMessage((msg) => { if (msg.ref === ref) { this.off([onMsgRef]); callback(Date.now() - startTime); } }); return true; } /** * @private * * @param {Function} */ transportName(transport) { switch (transport) { case LongPoll: return "LongPoll"; default: return transport.name; } } /** * @private */ transportConnect() { this.connectClock++; this.closeWasClean = false; let protocols = void 0; if (this.authToken) { protocols = ["phoenix", `${AUTH_TOKEN_PREFIX}${btoa(this.authToken).replace(/=/g, "")}`]; } this.conn = new this.transport(this.endPointURL(), protocols); this.conn.binaryType = this.binaryType; this.conn.timeout = this.longpollerTimeout; this.conn.onopen = () => this.onConnOpen(); this.conn.onerror = (error) => this.onConnError(error); this.conn.onmessage = (event) => this.onConnMessage(event); this.conn.onclose = (event) => this.onConnClose(event); } getSession(key) { return this.sessionStore && this.sessionStore.getItem(key); } storeSession(key, val) { this.sessionStore && this.sessionStore.setItem(key, val); } connectWithFallback(fallbackTransport, fallbackThreshold = 2500) { clearTimeout(this.fallbackTimer); let established = false; let primaryTransport = true; let openRef, errorRef; let fallbackTransportName = this.transportName(fallbackTransport); let fallback = (reason) => { this.log("transport", `falling back to ${fallbackTransportName}...`, reason); this.off([openRef, errorRef]); primaryTransport = false; this.replaceTransport(fallbackTransport); this.transportConnect(); }; if (this.getSession(`phx:fallback:${fallbackTransportName}`)) { return fallback("memorized"); } this.fallbackTimer = setTimeout(fallback, fallbackThreshold); errorRef = this.onError((reason) => { this.log("transport", "error", reason); if (primaryTransport && !established) { clearTimeout(this.fallbackTimer); fallback(reason); } }); if (this.fallbackRef) { this.off([this.fallbackRef]); } this.fallbackRef = this.onOpen(() => { established = true; if (!primaryTransport) { let fallbackTransportName2 = this.transportName(fallbackTransport); if (!this.primaryPassedHealthCheck) { this.storeSession(`phx:fallback:${fallbackTransportName2}`, "true"); } return this.log("transport", `established ${fallbackTransportName2} fallback`); } clearTimeout(this.fallbackTimer); this.fallbackTimer = setTimeout(fallback, fallbackThreshold); this.ping((rtt) => { this.log("transport", "connected to primary after", rtt); this.primaryPassedHealthCheck = true; clearTimeout(this.fallbackTimer); }); }); this.transportConnect(); } clearHeartbeats() { clearTimeout(this.heartbeatTimer); clearTimeout(this.heartbeatTimeoutTimer); } onConnOpen() { if (this.hasLogger()) this.log("transport", `${this.transportName(this.transport)} connected to ${this.endPointURL()}`); this.closeWasClean = false; this.disconnecting = false; this.establishedConnections++; this.flushSendBuffer(); this.reconnectTimer.reset(); this.resetHeartbeat(); this.stateChangeCallbacks.open.forEach(([, callback]) => callback()); } /** * @private */ heartbeatTimeout() { if (this.pendingHeartbeatRef) { this.pendingHeartbeatRef = null; if (this.hasLogger()) { this.log("transport", "heartbeat timeout. Attempting to re-establish connection"); } this.triggerChanError(); this.closeWasClean = false; this.teardown(() => this.reconnectTimer.scheduleTimeout(), WS_CLOSE_NORMAL, "heartbeat timeout"); } } resetHeartbeat() { if (this.conn && this.conn.skipHeartbeat) { return; } this.pendingHeartbeatRef = null; this.clearHeartbeats(); this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs); } teardown(callback, code, reason) { if (!this.conn) { return callback && callback(); } const connToClose = this.conn; this.waitForBufferDone(connToClose, () => { if (code) { connToClose.close(code, reason || ""); } else { connToClose.close(); } this.waitForSocketClosed(connToClose, () => { if (this.conn === connToClose) { this.conn.onopen = function() { }; this.conn.onerror = function() { }; this.conn.onmessage = function() { }; this.conn.onclose = function() { }; this.conn = null; } callback && callback(); }); }); } waitForBufferDone(conn, callback, tries = 1) { if (tries === 5 || !conn.bufferedAmount) { callback(); return; } setTimeout(() => { this.waitForBufferDone(conn, callback, tries + 1); }, 150 * tries); } waitForSocketClosed(conn, callback, tries = 1) { if (tries === 5 || conn.readyState === SOCKET_STATES.closed) { callback(); return; } setTimeout(() => { this.waitForSocketClosed(conn, callback, tries + 1); }, 150 * tries); } onConnClose(event) { if (this.conn) this.conn.onclose = () => { }; let closeCode = event && event.code; if (this.hasLogger()) this.log("transport", "close", event); this.triggerChanError(); this.clearHeartbeats(); if (!this.closeWasClean && closeCode !== 1e3) { this.reconnectTimer.scheduleTimeout(); } this.stateChangeCallbacks.close.forEach(([, callback]) => callback(event)); } /** * @private */ onConnError(error) { if (this.hasLogger()) this.log("transport", error); let transportBefore = this.transport; let establishedBefore = this.establishedConnections; this.stateChangeCallbacks.error.forEach(([, callback]) => { callback(error, transportBefore, establishedBefore); }); if (transportBefore === this.transport || establishedBefore > 0) { this.triggerChanError(); } } /** * @private */ triggerChanError() { this.channels.forEach((channel) => { if (!(channel.isErrored() || channel.isLeaving() || channel.isClosed())) { channel.trigger(CHANNEL_EVENTS.error); } }); } /** * @returns {string} */ connectionState() { switch (this.conn && this.conn.readyState) { case SOCKET_STATES.connecting: return "connecting"; case SOCKET_STATES.open: return "open"; case SOCKET_STATES.closing: return "closing"; default: return "closed"; } } /** * @returns {boolean} */ isConnected() { return this.connectionState() === "open"; } /** * @private * * @param {Channel} */ remove(channel) { this.off(channel.stateChangeRefs); this.channels = this.channels.filter((c) => c !== channel); } /** * Removes `onOpen`, `onClose`, `onError,` and `onMessage` registrations. * * @param {refs} - list of refs returned by calls to * `onOpen`, `onClose`, `onError,` and `onMessage` */ off(refs) { for (let key in this.stateChangeCallbacks) { this.stateChangeCallbacks[key] = this.stateChangeCallbacks[key].filter(([ref]) => { return refs.indexOf(ref) === -1; }); } } /** * Initiates a new channel for the given topic * * @param {string} topic * @param {Object} chanParams - Parameters for the channel * @returns {Channel} */ channel(topic, chanParams = {}) { let chan = new Channel(topic, chanParams, this); this.channels.push(chan); return chan; } /** * @param {Object} data */ push(data) { if (this.hasLogger()) { let { topic, event, payload, ref, join_ref } = data; this.log("push", `${topic} ${event} (${join_ref}, ${ref})`, payload); } if (this.isConnected()) { this.encode(data, (result) => this.conn.send(result)); } else { this.sendBuffer.push(() => this.encode(data, (result) => this.conn.send(result))); } } /** * Return the next message ref, accounting for overflows * @returns {string} */ makeRef() { let newRef = this.ref + 1; if (newRef === this.ref) { this.ref = 0; } else { this.ref = newRef; } return this.ref.toString(); } sendHeartbeat() { if (this.pendingHeartbeatRef && !this.isConnected()) { return; } this.pendingHeartbeatRef = this.makeRef(); this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref: this.pendingHeartbeatRef }); this.heartbeatTimeoutTimer = setTimeout(() => this.heartbeatTimeout(), this.heartbeatIntervalMs); } flushSendBuffer() { if (this.isConnected() && this.sendBuffer.length > 0) { this.sendBuffer.forEach((callback) => callback()); this.sendBuffer = []; } } onConnMessage(rawMessage) { this.decode(rawMessage.data, (msg) => { let { topic, event, payload, ref, join_ref } = msg; if (ref && ref === this.pendingHeartbeatRef) { this.clearHeartbeats(); this.pendingHeartbeatRef = null; this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs); } if (this.hasLogger()) this.log("receive", `${payload.status || ""} ${topic} ${event} ${ref && "(" + ref + ")" || ""}`, payload); for (let i = 0; i < this.channels.length; i++) { const channel = this.channels[i]; if (!channel.isMember(topic, event, payload, join_ref)) { continue; } channel.trigger(event, payload, ref, join_ref); } for (let i = 0; i < this.stateChangeCallbacks.message.length; i++) { let [, callback] = this.stateChangeCallbacks.message[i]; callback(msg); } }); } leaveOpenTopic(topic) { let dupChannel = this.channels.find((c) => c.topic === topic && (c.isJoined() || c.isJoining())); if (dupChannel) { if (this.hasLogger()) this.log("transport", `leaving duplicate topic "${topic}"`); dupChannel.leave(); } } }; //# sourceMappingURL=phoenix.cjs.js.map ================================================ FILE: priv/static/phoenix.js ================================================ var Phoenix = (() => { var __defProp = Object.defineProperty; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; var __hasOwnProp = Object.prototype.hasOwnProperty; var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true }); }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); } return to; }; var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); // js/phoenix/index.js var phoenix_exports = {}; __export(phoenix_exports, { Channel: () => Channel, LongPoll: () => LongPoll, Presence: () => Presence, Serializer: () => serializer_default, Socket: () => Socket }); // js/phoenix/utils.js var closure = (value) => { if (typeof value === "function") { return value; } else { let closure2 = function() { return value; }; return closure2; } }; // js/phoenix/constants.js var globalSelf = typeof self !== "undefined" ? self : null; var phxWindow = typeof window !== "undefined" ? window : null; var global = globalSelf || phxWindow || globalThis; var DEFAULT_VSN = "2.0.0"; var SOCKET_STATES = { connecting: 0, open: 1, closing: 2, closed: 3 }; var DEFAULT_TIMEOUT = 1e4; var WS_CLOSE_NORMAL = 1e3; var CHANNEL_STATES = { closed: "closed", errored: "errored", joined: "joined", joining: "joining", leaving: "leaving" }; var CHANNEL_EVENTS = { close: "phx_close", error: "phx_error", join: "phx_join", reply: "phx_reply", leave: "phx_leave" }; var TRANSPORTS = { longpoll: "longpoll", websocket: "websocket" }; var XHR_STATES = { complete: 4 }; var AUTH_TOKEN_PREFIX = "base64url.bearer.phx."; // js/phoenix/push.js var Push = class { constructor(channel, event, payload, timeout) { this.channel = channel; this.event = event; this.payload = payload || function() { return {}; }; this.receivedResp = null; this.timeout = timeout; this.timeoutTimer = null; this.recHooks = []; this.sent = false; } /** * * @param {number} timeout */ resend(timeout) { this.timeout = timeout; this.reset(); this.send(); } /** * */ send() { if (this.hasReceived("timeout")) { return; } this.startTimeout(); this.sent = true; this.channel.socket.push({ topic: this.channel.topic, event: this.event, payload: this.payload(), ref: this.ref, join_ref: this.channel.joinRef() }); } /** * * @param {*} status * @param {*} callback */ receive(status, callback) { if (this.hasReceived(status)) { callback(this.receivedResp.response); } this.recHooks.push({ status, callback }); return this; } /** * @private */ reset() { this.cancelRefEvent(); this.ref = null; this.refEvent = null; this.receivedResp = null; this.sent = false; } /** * @private */ matchReceive({ status, response, _ref }) { this.recHooks.filter((h) => h.status === status).forEach((h) => h.callback(response)); } /** * @private */ cancelRefEvent() { if (!this.refEvent) { return; } this.channel.off(this.refEvent); } /** * @private */ cancelTimeout() { clearTimeout(this.timeoutTimer); this.timeoutTimer = null; } /** * @private */ startTimeout() { if (this.timeoutTimer) { this.cancelTimeout(); } this.ref = this.channel.socket.makeRef(); this.refEvent = this.channel.replyEventName(this.ref); this.channel.on(this.refEvent, (payload) => { this.cancelRefEvent(); this.cancelTimeout(); this.receivedResp = payload; this.matchReceive(payload); }); this.timeoutTimer = setTimeout(() => { this.trigger("timeout", {}); }, this.timeout); } /** * @private */ hasReceived(status) { return this.receivedResp && this.receivedResp.status === status; } /** * @private */ trigger(status, response) { this.channel.trigger(this.refEvent, { status, response }); } }; // js/phoenix/timer.js var Timer = class { constructor(callback, timerCalc) { this.callback = callback; this.timerCalc = timerCalc; this.timer = null; this.tries = 0; } reset() { this.tries = 0; clearTimeout(this.timer); } /** * Cancels any previous scheduleTimeout and schedules callback */ scheduleTimeout() { clearTimeout(this.timer); this.timer = setTimeout(() => { this.tries = this.tries + 1; this.callback(); }, this.timerCalc(this.tries + 1)); } }; // js/phoenix/channel.js var Channel = class { constructor(topic, params, socket) { this.state = CHANNEL_STATES.closed; this.topic = topic; this.params = closure(params || {}); this.socket = socket; this.bindings = []; this.bindingRef = 0; this.timeout = this.socket.timeout; this.joinedOnce = false; this.joinPush = new Push(this, CHANNEL_EVENTS.join, this.params, this.timeout); this.pushBuffer = []; this.stateChangeRefs = []; this.rejoinTimer = new Timer(() => { if (this.socket.isConnected()) { this.rejoin(); } }, this.socket.rejoinAfterMs); this.stateChangeRefs.push(this.socket.onError(() => this.rejoinTimer.reset())); this.stateChangeRefs.push( this.socket.onOpen(() => { this.rejoinTimer.reset(); if (this.isErrored()) { this.rejoin(); } }) ); this.joinPush.receive("ok", () => { this.state = CHANNEL_STATES.joined; this.rejoinTimer.reset(); this.pushBuffer.forEach((pushEvent) => pushEvent.send()); this.pushBuffer = []; }); this.joinPush.receive("error", () => { this.state = CHANNEL_STATES.errored; if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.onClose(() => { this.rejoinTimer.reset(); if (this.socket.hasLogger()) this.socket.log("channel", `close ${this.topic} ${this.joinRef()}`); this.state = CHANNEL_STATES.closed; this.socket.remove(this); }); this.onError((reason) => { if (this.socket.hasLogger()) this.socket.log("channel", `error ${this.topic}`, reason); if (this.isJoining()) { this.joinPush.reset(); } this.state = CHANNEL_STATES.errored; if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.joinPush.receive("timeout", () => { if (this.socket.hasLogger()) this.socket.log("channel", `timeout ${this.topic} (${this.joinRef()})`, this.joinPush.timeout); let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), this.timeout); leavePush.send(); this.state = CHANNEL_STATES.errored; this.joinPush.reset(); if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.on(CHANNEL_EVENTS.reply, (payload, ref) => { this.trigger(this.replyEventName(ref), payload); }); } /** * Join the channel * @param {integer} timeout * @returns {Push} */ join(timeout = this.timeout) { if (this.joinedOnce) { throw new Error("tried to join multiple times. 'join' can only be called a single time per channel instance"); } else { this.timeout = timeout; this.joinedOnce = true; this.rejoin(); return this.joinPush; } } /** * Hook into channel close * @param {Function} callback */ onClose(callback) { this.on(CHANNEL_EVENTS.close, callback); } /** * Hook into channel errors * @param {Function} callback */ onError(callback) { return this.on(CHANNEL_EVENTS.error, (reason) => callback(reason)); } /** * Subscribes on channel events * * Subscription returns a ref counter, which can be used later to * unsubscribe the exact event listener * * @example * const ref1 = channel.on("event", do_stuff) * const ref2 = channel.on("event", do_other_stuff) * channel.off("event", ref1) * // Since unsubscription, do_stuff won't fire, * // while do_other_stuff will keep firing on the "event" * * @param {string} event * @param {Function} callback * @returns {integer} ref */ on(event, callback) { let ref = this.bindingRef++; this.bindings.push({ event, ref, callback }); return ref; } /** * Unsubscribes off of channel events * * Use the ref returned from a channel.on() to unsubscribe one * handler, or pass nothing for the ref to unsubscribe all * handlers for the given event. * * @example * // Unsubscribe the do_stuff handler * const ref1 = channel.on("event", do_stuff) * channel.off("event", ref1) * * // Unsubscribe all handlers from event * channel.off("event") * * @param {string} event * @param {integer} ref */ off(event, ref) { this.bindings = this.bindings.filter((bind) => { return !(bind.event === event && (typeof ref === "undefined" || ref === bind.ref)); }); } /** * @private */ canPush() { return this.socket.isConnected() && this.isJoined(); } /** * Sends a message `event` to phoenix with the payload `payload`. * Phoenix receives this in the `handle_in(event, payload, socket)` * function. if phoenix replies or it times out (default 10000ms), * then optionally the reply can be received. * * @example * channel.push("event") * .receive("ok", payload => console.log("phoenix replied:", payload)) * .receive("error", err => console.log("phoenix errored", err)) * .receive("timeout", () => console.log("timed out pushing")) * @param {string} event * @param {Object} payload * @param {number} [timeout] * @returns {Push} */ push(event, payload, timeout = this.timeout) { payload = payload || {}; if (!this.joinedOnce) { throw new Error(`tried to push '${event}' to '${this.topic}' before joining. Use channel.join() before pushing events`); } let pushEvent = new Push(this, event, function() { return payload; }, timeout); if (this.canPush()) { pushEvent.send(); } else { pushEvent.startTimeout(); this.pushBuffer.push(pushEvent); } return pushEvent; } /** Leaves the channel * * Unsubscribes from server events, and * instructs channel to terminate on server * * Triggers onClose() hooks * * To receive leave acknowledgements, use the `receive` * hook to bind to the server ack, ie: * * @example * channel.leave().receive("ok", () => alert("left!") ) * * @param {integer} timeout * @returns {Push} */ leave(timeout = this.timeout) { this.rejoinTimer.reset(); this.joinPush.cancelTimeout(); this.state = CHANNEL_STATES.leaving; let onClose = () => { if (this.socket.hasLogger()) this.socket.log("channel", `leave ${this.topic}`); this.trigger(CHANNEL_EVENTS.close, "leave"); }; let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), timeout); leavePush.receive("ok", () => onClose()).receive("timeout", () => onClose()); leavePush.send(); if (!this.canPush()) { leavePush.trigger("ok", {}); } return leavePush; } /** * Overridable message hook * * Receives all events for specialized message handling * before dispatching to the channel callbacks. * * Must return the payload, modified or unmodified * @param {string} event * @param {Object} payload * @param {integer} ref * @returns {Object} */ onMessage(_event, payload, _ref) { return payload; } /** * @private */ isMember(topic, event, payload, joinRef) { if (this.topic !== topic) { return false; } if (joinRef && joinRef !== this.joinRef()) { if (this.socket.hasLogger()) this.socket.log("channel", "dropping outdated message", { topic, event, payload, joinRef }); return false; } else { return true; } } /** * @private */ joinRef() { return this.joinPush.ref; } /** * @private */ rejoin(timeout = this.timeout) { if (this.isLeaving()) { return; } this.socket.leaveOpenTopic(this.topic); this.state = CHANNEL_STATES.joining; this.joinPush.resend(timeout); } /** * @private */ trigger(event, payload, ref, joinRef) { let handledPayload = this.onMessage(event, payload, ref, joinRef); if (payload && !handledPayload) { throw new Error("channel onMessage callbacks must return the payload, modified or unmodified"); } let eventBindings = this.bindings.filter((bind) => bind.event === event); for (let i = 0; i < eventBindings.length; i++) { let bind = eventBindings[i]; bind.callback(handledPayload, ref, joinRef || this.joinRef()); } } /** * @private */ replyEventName(ref) { return `chan_reply_${ref}`; } /** * @private */ isClosed() { return this.state === CHANNEL_STATES.closed; } /** * @private */ isErrored() { return this.state === CHANNEL_STATES.errored; } /** * @private */ isJoined() { return this.state === CHANNEL_STATES.joined; } /** * @private */ isJoining() { return this.state === CHANNEL_STATES.joining; } /** * @private */ isLeaving() { return this.state === CHANNEL_STATES.leaving; } }; // js/phoenix/ajax.js var Ajax = class { static request(method, endPoint, headers, body, timeout, ontimeout, callback) { if (global.XDomainRequest) { let req = new global.XDomainRequest(); return this.xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback); } else if (global.XMLHttpRequest) { let req = new global.XMLHttpRequest(); return this.xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback); } else if (global.fetch && global.AbortController) { return this.fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback); } else { throw new Error("No suitable XMLHttpRequest implementation found"); } } static fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback) { let options = { method, headers, body }; let controller = null; if (timeout) { controller = new AbortController(); const _timeoutId = setTimeout(() => controller.abort(), timeout); options.signal = controller.signal; } global.fetch(endPoint, options).then((response) => response.text()).then((data) => this.parseJSON(data)).then((data) => callback && callback(data)).catch((err) => { if (err.name === "AbortError" && ontimeout) { ontimeout(); } else { callback && callback(null); } }); return controller; } static xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback) { req.timeout = timeout; req.open(method, endPoint); req.onload = () => { let response = this.parseJSON(req.responseText); callback && callback(response); }; if (ontimeout) { req.ontimeout = ontimeout; } req.onprogress = () => { }; req.send(body); return req; } static xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback) { req.open(method, endPoint, true); req.timeout = timeout; for (let [key, value] of Object.entries(headers)) { req.setRequestHeader(key, value); } req.onerror = () => callback && callback(null); req.onreadystatechange = () => { if (req.readyState === XHR_STATES.complete && callback) { let response = this.parseJSON(req.responseText); callback(response); } }; if (ontimeout) { req.ontimeout = ontimeout; } req.send(body); return req; } static parseJSON(resp) { if (!resp || resp === "") { return null; } try { return JSON.parse(resp); } catch (e) { console && console.log("failed to parse JSON response", resp); return null; } } static serialize(obj, parentKey) { let queryStr = []; for (var key in obj) { if (!Object.prototype.hasOwnProperty.call(obj, key)) { continue; } let paramKey = parentKey ? `${parentKey}[${key}]` : key; let paramVal = obj[key]; if (typeof paramVal === "object") { queryStr.push(this.serialize(paramVal, paramKey)); } else { queryStr.push(encodeURIComponent(paramKey) + "=" + encodeURIComponent(paramVal)); } } return queryStr.join("&"); } static appendParams(url, params) { if (Object.keys(params).length === 0) { return url; } let prefix = url.match(/\?/) ? "&" : "?"; return `${url}${prefix}${this.serialize(params)}`; } }; // js/phoenix/longpoll.js var arrayBufferToBase64 = (buffer) => { let binary = ""; let bytes = new Uint8Array(buffer); let len = bytes.byteLength; for (let i = 0; i < len; i++) { binary += String.fromCharCode(bytes[i]); } return btoa(binary); }; var LongPoll = class { constructor(endPoint, protocols) { if (protocols && protocols.length === 2 && protocols[1].startsWith(AUTH_TOKEN_PREFIX)) { this.authToken = atob(protocols[1].slice(AUTH_TOKEN_PREFIX.length)); } this.endPoint = null; this.token = null; this.skipHeartbeat = true; this.reqs = /* @__PURE__ */ new Set(); this.awaitingBatchAck = false; this.currentBatch = null; this.currentBatchTimer = null; this.batchBuffer = []; this.onopen = function() { }; this.onerror = function() { }; this.onmessage = function() { }; this.onclose = function() { }; this.pollEndpoint = this.normalizeEndpoint(endPoint); this.readyState = SOCKET_STATES.connecting; setTimeout(() => this.poll(), 0); } normalizeEndpoint(endPoint) { return endPoint.replace("ws://", "http://").replace("wss://", "https://").replace(new RegExp("(.*)/" + TRANSPORTS.websocket), "$1/" + TRANSPORTS.longpoll); } endpointURL() { return Ajax.appendParams(this.pollEndpoint, { token: this.token }); } closeAndRetry(code, reason, wasClean) { this.close(code, reason, wasClean); this.readyState = SOCKET_STATES.connecting; } ontimeout() { this.onerror("timeout"); this.closeAndRetry(1005, "timeout", false); } isActive() { return this.readyState === SOCKET_STATES.open || this.readyState === SOCKET_STATES.connecting; } poll() { const headers = { "Accept": "application/json" }; if (this.authToken) { headers["X-Phoenix-AuthToken"] = this.authToken; } this.ajax("GET", headers, null, () => this.ontimeout(), (resp) => { if (resp) { var { status, token, messages } = resp; if (status === 410 && this.token !== null) { this.onerror(410); this.closeAndRetry(3410, "session_gone", false); return; } this.token = token; } else { status = 0; } switch (status) { case 200: messages.forEach((msg) => { setTimeout(() => this.onmessage({ data: msg }), 0); }); this.poll(); break; case 204: this.poll(); break; case 410: this.readyState = SOCKET_STATES.open; this.onopen({}); this.poll(); break; case 403: this.onerror(403); this.close(1008, "forbidden", false); break; case 0: case 500: this.onerror(500); this.closeAndRetry(1011, "internal server error", 500); break; default: throw new Error(`unhandled poll status ${status}`); } }); } // we collect all pushes within the current event loop by // setTimeout 0, which optimizes back-to-back procedural // pushes against an empty buffer send(body) { if (typeof body !== "string") { body = arrayBufferToBase64(body); } if (this.currentBatch) { this.currentBatch.push(body); } else if (this.awaitingBatchAck) { this.batchBuffer.push(body); } else { this.currentBatch = [body]; this.currentBatchTimer = setTimeout(() => { this.batchSend(this.currentBatch); this.currentBatch = null; }, 0); } } batchSend(messages) { this.awaitingBatchAck = true; this.ajax("POST", { "Content-Type": "application/x-ndjson" }, messages.join("\n"), () => this.onerror("timeout"), (resp) => { this.awaitingBatchAck = false; if (!resp || resp.status !== 200) { this.onerror(resp && resp.status); this.closeAndRetry(1011, "internal server error", false); } else if (this.batchBuffer.length > 0) { this.batchSend(this.batchBuffer); this.batchBuffer = []; } }); } close(code, reason, wasClean) { for (let req of this.reqs) { req.abort(); } this.readyState = SOCKET_STATES.closed; let opts = Object.assign({ code: 1e3, reason: void 0, wasClean: true }, { code, reason, wasClean }); this.batchBuffer = []; clearTimeout(this.currentBatchTimer); this.currentBatchTimer = null; if (typeof CloseEvent !== "undefined") { this.onclose(new CloseEvent("close", opts)); } else { this.onclose(opts); } } ajax(method, headers, body, onCallerTimeout, callback) { let req; let ontimeout = () => { this.reqs.delete(req); onCallerTimeout(); }; req = Ajax.request(method, this.endpointURL(), headers, body, this.timeout, ontimeout, (resp) => { this.reqs.delete(req); if (this.isActive()) { callback(resp); } }); this.reqs.add(req); } }; // js/phoenix/presence.js var Presence = class _Presence { constructor(channel, opts = {}) { let events = opts.events || { state: "presence_state", diff: "presence_diff" }; this.state = {}; this.pendingDiffs = []; this.channel = channel; this.joinRef = null; this.caller = { onJoin: function() { }, onLeave: function() { }, onSync: function() { } }; this.channel.on(events.state, (newState) => { let { onJoin, onLeave, onSync } = this.caller; this.joinRef = this.channel.joinRef(); this.state = _Presence.syncState(this.state, newState, onJoin, onLeave); this.pendingDiffs.forEach((diff) => { this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave); }); this.pendingDiffs = []; onSync(); }); this.channel.on(events.diff, (diff) => { let { onJoin, onLeave, onSync } = this.caller; if (this.inPendingSyncState()) { this.pendingDiffs.push(diff); } else { this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave); onSync(); } }); } onJoin(callback) { this.caller.onJoin = callback; } onLeave(callback) { this.caller.onLeave = callback; } onSync(callback) { this.caller.onSync = callback; } list(by) { return _Presence.list(this.state, by); } inPendingSyncState() { return !this.joinRef || this.joinRef !== this.channel.joinRef(); } // lower-level public static API /** * Used to sync the list of presences on the server * with the client's state. An optional `onJoin` and `onLeave` callback can * be provided to react to changes in the client's local presences across * disconnects and reconnects with the server. * * @returns {Presence} */ static syncState(currentState, newState, onJoin, onLeave) { let state = this.clone(currentState); let joins = {}; let leaves = {}; this.map(state, (key, presence) => { if (!newState[key]) { leaves[key] = presence; } }); this.map(newState, (key, newPresence) => { let currentPresence = state[key]; if (currentPresence) { let newRefs = newPresence.metas.map((m) => m.phx_ref); let curRefs = currentPresence.metas.map((m) => m.phx_ref); let joinedMetas = newPresence.metas.filter((m) => curRefs.indexOf(m.phx_ref) < 0); let leftMetas = currentPresence.metas.filter((m) => newRefs.indexOf(m.phx_ref) < 0); if (joinedMetas.length > 0) { joins[key] = newPresence; joins[key].metas = joinedMetas; } if (leftMetas.length > 0) { leaves[key] = this.clone(currentPresence); leaves[key].metas = leftMetas; } } else { joins[key] = newPresence; } }); return this.syncDiff(state, { joins, leaves }, onJoin, onLeave); } /** * * Used to sync a diff of presence join and leave * events from the server, as they happen. Like `syncState`, `syncDiff` * accepts optional `onJoin` and `onLeave` callbacks to react to a user * joining or leaving from a device. * * @returns {Presence} */ static syncDiff(state, diff, onJoin, onLeave) { let { joins, leaves } = this.clone(diff); if (!onJoin) { onJoin = function() { }; } if (!onLeave) { onLeave = function() { }; } this.map(joins, (key, newPresence) => { let currentPresence = state[key]; state[key] = this.clone(newPresence); if (currentPresence) { let joinedRefs = state[key].metas.map((m) => m.phx_ref); let curMetas = currentPresence.metas.filter((m) => joinedRefs.indexOf(m.phx_ref) < 0); state[key].metas.unshift(...curMetas); } onJoin(key, currentPresence, newPresence); }); this.map(leaves, (key, leftPresence) => { let currentPresence = state[key]; if (!currentPresence) { return; } let refsToRemove = leftPresence.metas.map((m) => m.phx_ref); currentPresence.metas = currentPresence.metas.filter((p) => { return refsToRemove.indexOf(p.phx_ref) < 0; }); onLeave(key, currentPresence, leftPresence); if (currentPresence.metas.length === 0) { delete state[key]; } }); return state; } /** * Returns the array of presences, with selected metadata. * * @param {Object} presences * @param {Function} chooser * * @returns {Presence} */ static list(presences, chooser) { if (!chooser) { chooser = function(key, pres) { return pres; }; } return this.map(presences, (key, presence) => { return chooser(key, presence); }); } // private static map(obj, func) { return Object.getOwnPropertyNames(obj).map((key) => func(key, obj[key])); } static clone(obj) { return JSON.parse(JSON.stringify(obj)); } }; // js/phoenix/serializer.js var serializer_default = { HEADER_LENGTH: 1, META_LENGTH: 4, KINDS: { push: 0, reply: 1, broadcast: 2 }, encode(msg, callback) { if (msg.payload.constructor === ArrayBuffer) { return callback(this.binaryEncode(msg)); } else { let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload]; return callback(JSON.stringify(payload)); } }, decode(rawPayload, callback) { if (rawPayload.constructor === ArrayBuffer) { return callback(this.binaryDecode(rawPayload)); } else { let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload); return callback({ join_ref, ref, topic, event, payload }); } }, // private binaryEncode(message) { let { join_ref, ref, event, topic, payload } = message; let metaLength = this.META_LENGTH + join_ref.length + ref.length + topic.length + event.length; let header = new ArrayBuffer(this.HEADER_LENGTH + metaLength); let view = new DataView(header); let offset = 0; view.setUint8(offset++, this.KINDS.push); view.setUint8(offset++, join_ref.length); view.setUint8(offset++, ref.length); view.setUint8(offset++, topic.length); view.setUint8(offset++, event.length); Array.from(join_ref, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(ref, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(topic, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(event, (char) => view.setUint8(offset++, char.charCodeAt(0))); var combined = new Uint8Array(header.byteLength + payload.byteLength); combined.set(new Uint8Array(header), 0); combined.set(new Uint8Array(payload), header.byteLength); return combined.buffer; }, binaryDecode(buffer) { let view = new DataView(buffer); let kind = view.getUint8(0); let decoder = new TextDecoder(); switch (kind) { case this.KINDS.push: return this.decodePush(buffer, view, decoder); case this.KINDS.reply: return this.decodeReply(buffer, view, decoder); case this.KINDS.broadcast: return this.decodeBroadcast(buffer, view, decoder); } }, decodePush(buffer, view, decoder) { let joinRefSize = view.getUint8(1); let topicSize = view.getUint8(2); let eventSize = view.getUint8(3); let offset = this.HEADER_LENGTH + this.META_LENGTH - 1; let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)); offset = offset + joinRefSize; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); return { join_ref: joinRef, ref: null, topic, event, payload: data }; }, decodeReply(buffer, view, decoder) { let joinRefSize = view.getUint8(1); let refSize = view.getUint8(2); let topicSize = view.getUint8(3); let eventSize = view.getUint8(4); let offset = this.HEADER_LENGTH + this.META_LENGTH; let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)); offset = offset + joinRefSize; let ref = decoder.decode(buffer.slice(offset, offset + refSize)); offset = offset + refSize; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); let payload = { status: event, response: data }; return { join_ref: joinRef, ref, topic, event: CHANNEL_EVENTS.reply, payload }; }, decodeBroadcast(buffer, view, decoder) { let topicSize = view.getUint8(1); let eventSize = view.getUint8(2); let offset = this.HEADER_LENGTH + 2; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); return { join_ref: null, ref: null, topic, event, payload: data }; } }; // js/phoenix/socket.js var Socket = class { constructor(endPoint, opts = {}) { this.stateChangeCallbacks = { open: [], close: [], error: [], message: [] }; this.channels = []; this.sendBuffer = []; this.ref = 0; this.fallbackRef = null; this.timeout = opts.timeout || DEFAULT_TIMEOUT; this.transport = opts.transport || global.WebSocket || LongPoll; this.primaryPassedHealthCheck = false; this.longPollFallbackMs = opts.longPollFallbackMs; this.fallbackTimer = null; this.sessionStore = opts.sessionStorage || global && global.sessionStorage; this.establishedConnections = 0; this.defaultEncoder = serializer_default.encode.bind(serializer_default); this.defaultDecoder = serializer_default.decode.bind(serializer_default); this.closeWasClean = true; this.disconnecting = false; this.binaryType = opts.binaryType || "arraybuffer"; this.connectClock = 1; this.pageHidden = false; if (this.transport !== LongPoll) { this.encode = opts.encode || this.defaultEncoder; this.decode = opts.decode || this.defaultDecoder; } else { this.encode = this.defaultEncoder; this.decode = this.defaultDecoder; } let awaitingConnectionOnPageShow = null; if (phxWindow && phxWindow.addEventListener) { phxWindow.addEventListener("pagehide", (_e) => { if (this.conn) { this.disconnect(); awaitingConnectionOnPageShow = this.connectClock; } }); phxWindow.addEventListener("pageshow", (_e) => { if (awaitingConnectionOnPageShow === this.connectClock) { awaitingConnectionOnPageShow = null; this.connect(); } }); phxWindow.addEventListener("visibilitychange", () => { if (document.visibilityState === "hidden") { this.pageHidden = true; } else { this.pageHidden = false; if (!this.isConnected() && !this.closeWasClean) { this.teardown(() => this.connect()); } } }); } this.heartbeatIntervalMs = opts.heartbeatIntervalMs || 3e4; this.rejoinAfterMs = (tries) => { if (opts.rejoinAfterMs) { return opts.rejoinAfterMs(tries); } else { return [1e3, 2e3, 5e3][tries - 1] || 1e4; } }; this.reconnectAfterMs = (tries) => { if (opts.reconnectAfterMs) { return opts.reconnectAfterMs(tries); } else { return [10, 50, 100, 150, 200, 250, 500, 1e3, 2e3][tries - 1] || 5e3; } }; this.logger = opts.logger || null; if (!this.logger && opts.debug) { this.logger = (kind, msg, data) => { console.log(`${kind}: ${msg}`, data); }; } this.longpollerTimeout = opts.longpollerTimeout || 2e4; this.params = closure(opts.params || {}); this.endPoint = `${endPoint}/${TRANSPORTS.websocket}`; this.vsn = opts.vsn || DEFAULT_VSN; this.heartbeatTimeoutTimer = null; this.heartbeatTimer = null; this.pendingHeartbeatRef = null; this.reconnectTimer = new Timer(() => { if (this.pageHidden) { this.log("Not reconnecting as page is hidden!"); this.teardown(); return; } this.teardown(() => this.connect()); }, this.reconnectAfterMs); this.authToken = opts.authToken; } /** * Returns the LongPoll transport reference */ getLongPollTransport() { return LongPoll; } /** * Disconnects and replaces the active transport * * @param {Function} newTransport - The new transport class to instantiate * */ replaceTransport(newTransport) { this.connectClock++; this.closeWasClean = true; clearTimeout(this.fallbackTimer); this.reconnectTimer.reset(); if (this.conn) { this.conn.close(); this.conn = null; } this.transport = newTransport; } /** * Returns the socket protocol * * @returns {string} */ protocol() { return location.protocol.match(/^https/) ? "wss" : "ws"; } /** * The fully qualified socket url * * @returns {string} */ endPointURL() { let uri = Ajax.appendParams( Ajax.appendParams(this.endPoint, this.params()), { vsn: this.vsn } ); if (uri.charAt(0) !== "/") { return uri; } if (uri.charAt(1) === "/") { return `${this.protocol()}:${uri}`; } return `${this.protocol()}://${location.host}${uri}`; } /** * Disconnects the socket * * See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes for valid status codes. * * @param {Function} callback - Optional callback which is called after socket is disconnected. * @param {integer} code - A status code for disconnection (Optional). * @param {string} reason - A textual description of the reason to disconnect. (Optional) */ disconnect(callback, code, reason) { this.connectClock++; this.disconnecting = true; this.closeWasClean = true; clearTimeout(this.fallbackTimer); this.reconnectTimer.reset(); this.teardown(() => { this.disconnecting = false; callback && callback(); }, code, reason); } /** * * @param {Object} params - The params to send when connecting, for example `{user_id: userToken}` * * Passing params to connect is deprecated; pass them in the Socket constructor instead: * `new Socket("/socket", {params: {user_id: userToken}})`. */ connect(params) { if (params) { console && console.log("passing params to connect is deprecated. Instead pass :params to the Socket constructor"); this.params = closure(params); } if (this.conn && !this.disconnecting) { return; } if (this.longPollFallbackMs && this.transport !== LongPoll) { this.connectWithFallback(LongPoll, this.longPollFallbackMs); } else { this.transportConnect(); } } /** * Logs the message. Override `this.logger` for specialized logging. noops by default * @param {string} kind * @param {string} msg * @param {Object} data */ log(kind, msg, data) { this.logger && this.logger(kind, msg, data); } /** * Returns true if a logger has been set on this socket. */ hasLogger() { return this.logger !== null; } /** * Registers callbacks for connection open events * * @example socket.onOpen(function(){ console.info("the socket was opened") }) * * @param {Function} callback */ onOpen(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.open.push([ref, callback]); return ref; } /** * Registers callbacks for connection close events * @param {Function} callback */ onClose(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.close.push([ref, callback]); return ref; } /** * Registers callbacks for connection error events * * @example socket.onError(function(error){ alert("An error occurred") }) * * @param {Function} callback */ onError(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.error.push([ref, callback]); return ref; } /** * Registers callbacks for connection message events * @param {Function} callback */ onMessage(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.message.push([ref, callback]); return ref; } /** * Pings the server and invokes the callback with the RTT in milliseconds * @param {Function} callback * * Returns true if the ping was pushed or false if unable to be pushed. */ ping(callback) { if (!this.isConnected()) { return false; } let ref = this.makeRef(); let startTime = Date.now(); this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref }); let onMsgRef = this.onMessage((msg) => { if (msg.ref === ref) { this.off([onMsgRef]); callback(Date.now() - startTime); } }); return true; } /** * @private * * @param {Function} */ transportName(transport) { switch (transport) { case LongPoll: return "LongPoll"; default: return transport.name; } } /** * @private */ transportConnect() { this.connectClock++; this.closeWasClean = false; let protocols = void 0; if (this.authToken) { protocols = ["phoenix", `${AUTH_TOKEN_PREFIX}${btoa(this.authToken).replace(/=/g, "")}`]; } this.conn = new this.transport(this.endPointURL(), protocols); this.conn.binaryType = this.binaryType; this.conn.timeout = this.longpollerTimeout; this.conn.onopen = () => this.onConnOpen(); this.conn.onerror = (error) => this.onConnError(error); this.conn.onmessage = (event) => this.onConnMessage(event); this.conn.onclose = (event) => this.onConnClose(event); } getSession(key) { return this.sessionStore && this.sessionStore.getItem(key); } storeSession(key, val) { this.sessionStore && this.sessionStore.setItem(key, val); } connectWithFallback(fallbackTransport, fallbackThreshold = 2500) { clearTimeout(this.fallbackTimer); let established = false; let primaryTransport = true; let openRef, errorRef; let fallbackTransportName = this.transportName(fallbackTransport); let fallback = (reason) => { this.log("transport", `falling back to ${fallbackTransportName}...`, reason); this.off([openRef, errorRef]); primaryTransport = false; this.replaceTransport(fallbackTransport); this.transportConnect(); }; if (this.getSession(`phx:fallback:${fallbackTransportName}`)) { return fallback("memorized"); } this.fallbackTimer = setTimeout(fallback, fallbackThreshold); errorRef = this.onError((reason) => { this.log("transport", "error", reason); if (primaryTransport && !established) { clearTimeout(this.fallbackTimer); fallback(reason); } }); if (this.fallbackRef) { this.off([this.fallbackRef]); } this.fallbackRef = this.onOpen(() => { established = true; if (!primaryTransport) { let fallbackTransportName2 = this.transportName(fallbackTransport); if (!this.primaryPassedHealthCheck) { this.storeSession(`phx:fallback:${fallbackTransportName2}`, "true"); } return this.log("transport", `established ${fallbackTransportName2} fallback`); } clearTimeout(this.fallbackTimer); this.fallbackTimer = setTimeout(fallback, fallbackThreshold); this.ping((rtt) => { this.log("transport", "connected to primary after", rtt); this.primaryPassedHealthCheck = true; clearTimeout(this.fallbackTimer); }); }); this.transportConnect(); } clearHeartbeats() { clearTimeout(this.heartbeatTimer); clearTimeout(this.heartbeatTimeoutTimer); } onConnOpen() { if (this.hasLogger()) this.log("transport", `${this.transportName(this.transport)} connected to ${this.endPointURL()}`); this.closeWasClean = false; this.disconnecting = false; this.establishedConnections++; this.flushSendBuffer(); this.reconnectTimer.reset(); this.resetHeartbeat(); this.stateChangeCallbacks.open.forEach(([, callback]) => callback()); } /** * @private */ heartbeatTimeout() { if (this.pendingHeartbeatRef) { this.pendingHeartbeatRef = null; if (this.hasLogger()) { this.log("transport", "heartbeat timeout. Attempting to re-establish connection"); } this.triggerChanError(); this.closeWasClean = false; this.teardown(() => this.reconnectTimer.scheduleTimeout(), WS_CLOSE_NORMAL, "heartbeat timeout"); } } resetHeartbeat() { if (this.conn && this.conn.skipHeartbeat) { return; } this.pendingHeartbeatRef = null; this.clearHeartbeats(); this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs); } teardown(callback, code, reason) { if (!this.conn) { return callback && callback(); } const connToClose = this.conn; this.waitForBufferDone(connToClose, () => { if (code) { connToClose.close(code, reason || ""); } else { connToClose.close(); } this.waitForSocketClosed(connToClose, () => { if (this.conn === connToClose) { this.conn.onopen = function() { }; this.conn.onerror = function() { }; this.conn.onmessage = function() { }; this.conn.onclose = function() { }; this.conn = null; } callback && callback(); }); }); } waitForBufferDone(conn, callback, tries = 1) { if (tries === 5 || !conn.bufferedAmount) { callback(); return; } setTimeout(() => { this.waitForBufferDone(conn, callback, tries + 1); }, 150 * tries); } waitForSocketClosed(conn, callback, tries = 1) { if (tries === 5 || conn.readyState === SOCKET_STATES.closed) { callback(); return; } setTimeout(() => { this.waitForSocketClosed(conn, callback, tries + 1); }, 150 * tries); } onConnClose(event) { if (this.conn) this.conn.onclose = () => { }; let closeCode = event && event.code; if (this.hasLogger()) this.log("transport", "close", event); this.triggerChanError(); this.clearHeartbeats(); if (!this.closeWasClean && closeCode !== 1e3) { this.reconnectTimer.scheduleTimeout(); } this.stateChangeCallbacks.close.forEach(([, callback]) => callback(event)); } /** * @private */ onConnError(error) { if (this.hasLogger()) this.log("transport", error); let transportBefore = this.transport; let establishedBefore = this.establishedConnections; this.stateChangeCallbacks.error.forEach(([, callback]) => { callback(error, transportBefore, establishedBefore); }); if (transportBefore === this.transport || establishedBefore > 0) { this.triggerChanError(); } } /** * @private */ triggerChanError() { this.channels.forEach((channel) => { if (!(channel.isErrored() || channel.isLeaving() || channel.isClosed())) { channel.trigger(CHANNEL_EVENTS.error); } }); } /** * @returns {string} */ connectionState() { switch (this.conn && this.conn.readyState) { case SOCKET_STATES.connecting: return "connecting"; case SOCKET_STATES.open: return "open"; case SOCKET_STATES.closing: return "closing"; default: return "closed"; } } /** * @returns {boolean} */ isConnected() { return this.connectionState() === "open"; } /** * @private * * @param {Channel} */ remove(channel) { this.off(channel.stateChangeRefs); this.channels = this.channels.filter((c) => c !== channel); } /** * Removes `onOpen`, `onClose`, `onError,` and `onMessage` registrations. * * @param {refs} - list of refs returned by calls to * `onOpen`, `onClose`, `onError,` and `onMessage` */ off(refs) { for (let key in this.stateChangeCallbacks) { this.stateChangeCallbacks[key] = this.stateChangeCallbacks[key].filter(([ref]) => { return refs.indexOf(ref) === -1; }); } } /** * Initiates a new channel for the given topic * * @param {string} topic * @param {Object} chanParams - Parameters for the channel * @returns {Channel} */ channel(topic, chanParams = {}) { let chan = new Channel(topic, chanParams, this); this.channels.push(chan); return chan; } /** * @param {Object} data */ push(data) { if (this.hasLogger()) { let { topic, event, payload, ref, join_ref } = data; this.log("push", `${topic} ${event} (${join_ref}, ${ref})`, payload); } if (this.isConnected()) { this.encode(data, (result) => this.conn.send(result)); } else { this.sendBuffer.push(() => this.encode(data, (result) => this.conn.send(result))); } } /** * Return the next message ref, accounting for overflows * @returns {string} */ makeRef() { let newRef = this.ref + 1; if (newRef === this.ref) { this.ref = 0; } else { this.ref = newRef; } return this.ref.toString(); } sendHeartbeat() { if (this.pendingHeartbeatRef && !this.isConnected()) { return; } this.pendingHeartbeatRef = this.makeRef(); this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref: this.pendingHeartbeatRef }); this.heartbeatTimeoutTimer = setTimeout(() => this.heartbeatTimeout(), this.heartbeatIntervalMs); } flushSendBuffer() { if (this.isConnected() && this.sendBuffer.length > 0) { this.sendBuffer.forEach((callback) => callback()); this.sendBuffer = []; } } onConnMessage(rawMessage) { this.decode(rawMessage.data, (msg) => { let { topic, event, payload, ref, join_ref } = msg; if (ref && ref === this.pendingHeartbeatRef) { this.clearHeartbeats(); this.pendingHeartbeatRef = null; this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs); } if (this.hasLogger()) this.log("receive", `${payload.status || ""} ${topic} ${event} ${ref && "(" + ref + ")" || ""}`, payload); for (let i = 0; i < this.channels.length; i++) { const channel = this.channels[i]; if (!channel.isMember(topic, event, payload, join_ref)) { continue; } channel.trigger(event, payload, ref, join_ref); } for (let i = 0; i < this.stateChangeCallbacks.message.length; i++) { let [, callback] = this.stateChangeCallbacks.message[i]; callback(msg); } }); } leaveOpenTopic(topic) { let dupChannel = this.channels.find((c) => c.topic === topic && (c.isJoined() || c.isJoining())); if (dupChannel) { if (this.hasLogger()) this.log("transport", `leaving duplicate topic "${topic}"`); dupChannel.leave(); } } }; return __toCommonJS(phoenix_exports); })(); ================================================ FILE: priv/static/phoenix.mjs ================================================ // js/phoenix/utils.js var closure = (value) => { if (typeof value === "function") { return value; } else { let closure2 = function() { return value; }; return closure2; } }; // js/phoenix/constants.js var globalSelf = typeof self !== "undefined" ? self : null; var phxWindow = typeof window !== "undefined" ? window : null; var global = globalSelf || phxWindow || globalThis; var DEFAULT_VSN = "2.0.0"; var SOCKET_STATES = { connecting: 0, open: 1, closing: 2, closed: 3 }; var DEFAULT_TIMEOUT = 1e4; var WS_CLOSE_NORMAL = 1e3; var CHANNEL_STATES = { closed: "closed", errored: "errored", joined: "joined", joining: "joining", leaving: "leaving" }; var CHANNEL_EVENTS = { close: "phx_close", error: "phx_error", join: "phx_join", reply: "phx_reply", leave: "phx_leave" }; var TRANSPORTS = { longpoll: "longpoll", websocket: "websocket" }; var XHR_STATES = { complete: 4 }; var AUTH_TOKEN_PREFIX = "base64url.bearer.phx."; // js/phoenix/push.js var Push = class { constructor(channel, event, payload, timeout) { this.channel = channel; this.event = event; this.payload = payload || function() { return {}; }; this.receivedResp = null; this.timeout = timeout; this.timeoutTimer = null; this.recHooks = []; this.sent = false; } /** * * @param {number} timeout */ resend(timeout) { this.timeout = timeout; this.reset(); this.send(); } /** * */ send() { if (this.hasReceived("timeout")) { return; } this.startTimeout(); this.sent = true; this.channel.socket.push({ topic: this.channel.topic, event: this.event, payload: this.payload(), ref: this.ref, join_ref: this.channel.joinRef() }); } /** * * @param {*} status * @param {*} callback */ receive(status, callback) { if (this.hasReceived(status)) { callback(this.receivedResp.response); } this.recHooks.push({ status, callback }); return this; } /** * @private */ reset() { this.cancelRefEvent(); this.ref = null; this.refEvent = null; this.receivedResp = null; this.sent = false; } /** * @private */ matchReceive({ status, response, _ref }) { this.recHooks.filter((h) => h.status === status).forEach((h) => h.callback(response)); } /** * @private */ cancelRefEvent() { if (!this.refEvent) { return; } this.channel.off(this.refEvent); } /** * @private */ cancelTimeout() { clearTimeout(this.timeoutTimer); this.timeoutTimer = null; } /** * @private */ startTimeout() { if (this.timeoutTimer) { this.cancelTimeout(); } this.ref = this.channel.socket.makeRef(); this.refEvent = this.channel.replyEventName(this.ref); this.channel.on(this.refEvent, (payload) => { this.cancelRefEvent(); this.cancelTimeout(); this.receivedResp = payload; this.matchReceive(payload); }); this.timeoutTimer = setTimeout(() => { this.trigger("timeout", {}); }, this.timeout); } /** * @private */ hasReceived(status) { return this.receivedResp && this.receivedResp.status === status; } /** * @private */ trigger(status, response) { this.channel.trigger(this.refEvent, { status, response }); } }; // js/phoenix/timer.js var Timer = class { constructor(callback, timerCalc) { this.callback = callback; this.timerCalc = timerCalc; this.timer = null; this.tries = 0; } reset() { this.tries = 0; clearTimeout(this.timer); } /** * Cancels any previous scheduleTimeout and schedules callback */ scheduleTimeout() { clearTimeout(this.timer); this.timer = setTimeout(() => { this.tries = this.tries + 1; this.callback(); }, this.timerCalc(this.tries + 1)); } }; // js/phoenix/channel.js var Channel = class { constructor(topic, params, socket) { this.state = CHANNEL_STATES.closed; this.topic = topic; this.params = closure(params || {}); this.socket = socket; this.bindings = []; this.bindingRef = 0; this.timeout = this.socket.timeout; this.joinedOnce = false; this.joinPush = new Push(this, CHANNEL_EVENTS.join, this.params, this.timeout); this.pushBuffer = []; this.stateChangeRefs = []; this.rejoinTimer = new Timer(() => { if (this.socket.isConnected()) { this.rejoin(); } }, this.socket.rejoinAfterMs); this.stateChangeRefs.push(this.socket.onError(() => this.rejoinTimer.reset())); this.stateChangeRefs.push( this.socket.onOpen(() => { this.rejoinTimer.reset(); if (this.isErrored()) { this.rejoin(); } }) ); this.joinPush.receive("ok", () => { this.state = CHANNEL_STATES.joined; this.rejoinTimer.reset(); this.pushBuffer.forEach((pushEvent) => pushEvent.send()); this.pushBuffer = []; }); this.joinPush.receive("error", () => { this.state = CHANNEL_STATES.errored; if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.onClose(() => { this.rejoinTimer.reset(); if (this.socket.hasLogger()) this.socket.log("channel", `close ${this.topic} ${this.joinRef()}`); this.state = CHANNEL_STATES.closed; this.socket.remove(this); }); this.onError((reason) => { if (this.socket.hasLogger()) this.socket.log("channel", `error ${this.topic}`, reason); if (this.isJoining()) { this.joinPush.reset(); } this.state = CHANNEL_STATES.errored; if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.joinPush.receive("timeout", () => { if (this.socket.hasLogger()) this.socket.log("channel", `timeout ${this.topic} (${this.joinRef()})`, this.joinPush.timeout); let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), this.timeout); leavePush.send(); this.state = CHANNEL_STATES.errored; this.joinPush.reset(); if (this.socket.isConnected()) { this.rejoinTimer.scheduleTimeout(); } }); this.on(CHANNEL_EVENTS.reply, (payload, ref) => { this.trigger(this.replyEventName(ref), payload); }); } /** * Join the channel * @param {integer} timeout * @returns {Push} */ join(timeout = this.timeout) { if (this.joinedOnce) { throw new Error("tried to join multiple times. 'join' can only be called a single time per channel instance"); } else { this.timeout = timeout; this.joinedOnce = true; this.rejoin(); return this.joinPush; } } /** * Hook into channel close * @param {Function} callback */ onClose(callback) { this.on(CHANNEL_EVENTS.close, callback); } /** * Hook into channel errors * @param {Function} callback */ onError(callback) { return this.on(CHANNEL_EVENTS.error, (reason) => callback(reason)); } /** * Subscribes on channel events * * Subscription returns a ref counter, which can be used later to * unsubscribe the exact event listener * * @example * const ref1 = channel.on("event", do_stuff) * const ref2 = channel.on("event", do_other_stuff) * channel.off("event", ref1) * // Since unsubscription, do_stuff won't fire, * // while do_other_stuff will keep firing on the "event" * * @param {string} event * @param {Function} callback * @returns {integer} ref */ on(event, callback) { let ref = this.bindingRef++; this.bindings.push({ event, ref, callback }); return ref; } /** * Unsubscribes off of channel events * * Use the ref returned from a channel.on() to unsubscribe one * handler, or pass nothing for the ref to unsubscribe all * handlers for the given event. * * @example * // Unsubscribe the do_stuff handler * const ref1 = channel.on("event", do_stuff) * channel.off("event", ref1) * * // Unsubscribe all handlers from event * channel.off("event") * * @param {string} event * @param {integer} ref */ off(event, ref) { this.bindings = this.bindings.filter((bind) => { return !(bind.event === event && (typeof ref === "undefined" || ref === bind.ref)); }); } /** * @private */ canPush() { return this.socket.isConnected() && this.isJoined(); } /** * Sends a message `event` to phoenix with the payload `payload`. * Phoenix receives this in the `handle_in(event, payload, socket)` * function. if phoenix replies or it times out (default 10000ms), * then optionally the reply can be received. * * @example * channel.push("event") * .receive("ok", payload => console.log("phoenix replied:", payload)) * .receive("error", err => console.log("phoenix errored", err)) * .receive("timeout", () => console.log("timed out pushing")) * @param {string} event * @param {Object} payload * @param {number} [timeout] * @returns {Push} */ push(event, payload, timeout = this.timeout) { payload = payload || {}; if (!this.joinedOnce) { throw new Error(`tried to push '${event}' to '${this.topic}' before joining. Use channel.join() before pushing events`); } let pushEvent = new Push(this, event, function() { return payload; }, timeout); if (this.canPush()) { pushEvent.send(); } else { pushEvent.startTimeout(); this.pushBuffer.push(pushEvent); } return pushEvent; } /** Leaves the channel * * Unsubscribes from server events, and * instructs channel to terminate on server * * Triggers onClose() hooks * * To receive leave acknowledgements, use the `receive` * hook to bind to the server ack, ie: * * @example * channel.leave().receive("ok", () => alert("left!") ) * * @param {integer} timeout * @returns {Push} */ leave(timeout = this.timeout) { this.rejoinTimer.reset(); this.joinPush.cancelTimeout(); this.state = CHANNEL_STATES.leaving; let onClose = () => { if (this.socket.hasLogger()) this.socket.log("channel", `leave ${this.topic}`); this.trigger(CHANNEL_EVENTS.close, "leave"); }; let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), timeout); leavePush.receive("ok", () => onClose()).receive("timeout", () => onClose()); leavePush.send(); if (!this.canPush()) { leavePush.trigger("ok", {}); } return leavePush; } /** * Overridable message hook * * Receives all events for specialized message handling * before dispatching to the channel callbacks. * * Must return the payload, modified or unmodified * @param {string} event * @param {Object} payload * @param {integer} ref * @returns {Object} */ onMessage(_event, payload, _ref) { return payload; } /** * @private */ isMember(topic, event, payload, joinRef) { if (this.topic !== topic) { return false; } if (joinRef && joinRef !== this.joinRef()) { if (this.socket.hasLogger()) this.socket.log("channel", "dropping outdated message", { topic, event, payload, joinRef }); return false; } else { return true; } } /** * @private */ joinRef() { return this.joinPush.ref; } /** * @private */ rejoin(timeout = this.timeout) { if (this.isLeaving()) { return; } this.socket.leaveOpenTopic(this.topic); this.state = CHANNEL_STATES.joining; this.joinPush.resend(timeout); } /** * @private */ trigger(event, payload, ref, joinRef) { let handledPayload = this.onMessage(event, payload, ref, joinRef); if (payload && !handledPayload) { throw new Error("channel onMessage callbacks must return the payload, modified or unmodified"); } let eventBindings = this.bindings.filter((bind) => bind.event === event); for (let i = 0; i < eventBindings.length; i++) { let bind = eventBindings[i]; bind.callback(handledPayload, ref, joinRef || this.joinRef()); } } /** * @private */ replyEventName(ref) { return `chan_reply_${ref}`; } /** * @private */ isClosed() { return this.state === CHANNEL_STATES.closed; } /** * @private */ isErrored() { return this.state === CHANNEL_STATES.errored; } /** * @private */ isJoined() { return this.state === CHANNEL_STATES.joined; } /** * @private */ isJoining() { return this.state === CHANNEL_STATES.joining; } /** * @private */ isLeaving() { return this.state === CHANNEL_STATES.leaving; } }; // js/phoenix/ajax.js var Ajax = class { static request(method, endPoint, headers, body, timeout, ontimeout, callback) { if (global.XDomainRequest) { let req = new global.XDomainRequest(); return this.xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback); } else if (global.XMLHttpRequest) { let req = new global.XMLHttpRequest(); return this.xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback); } else if (global.fetch && global.AbortController) { return this.fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback); } else { throw new Error("No suitable XMLHttpRequest implementation found"); } } static fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback) { let options = { method, headers, body }; let controller = null; if (timeout) { controller = new AbortController(); const _timeoutId = setTimeout(() => controller.abort(), timeout); options.signal = controller.signal; } global.fetch(endPoint, options).then((response) => response.text()).then((data) => this.parseJSON(data)).then((data) => callback && callback(data)).catch((err) => { if (err.name === "AbortError" && ontimeout) { ontimeout(); } else { callback && callback(null); } }); return controller; } static xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback) { req.timeout = timeout; req.open(method, endPoint); req.onload = () => { let response = this.parseJSON(req.responseText); callback && callback(response); }; if (ontimeout) { req.ontimeout = ontimeout; } req.onprogress = () => { }; req.send(body); return req; } static xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback) { req.open(method, endPoint, true); req.timeout = timeout; for (let [key, value] of Object.entries(headers)) { req.setRequestHeader(key, value); } req.onerror = () => callback && callback(null); req.onreadystatechange = () => { if (req.readyState === XHR_STATES.complete && callback) { let response = this.parseJSON(req.responseText); callback(response); } }; if (ontimeout) { req.ontimeout = ontimeout; } req.send(body); return req; } static parseJSON(resp) { if (!resp || resp === "") { return null; } try { return JSON.parse(resp); } catch { console && console.log("failed to parse JSON response", resp); return null; } } static serialize(obj, parentKey) { let queryStr = []; for (var key in obj) { if (!Object.prototype.hasOwnProperty.call(obj, key)) { continue; } let paramKey = parentKey ? `${parentKey}[${key}]` : key; let paramVal = obj[key]; if (typeof paramVal === "object") { queryStr.push(this.serialize(paramVal, paramKey)); } else { queryStr.push(encodeURIComponent(paramKey) + "=" + encodeURIComponent(paramVal)); } } return queryStr.join("&"); } static appendParams(url, params) { if (Object.keys(params).length === 0) { return url; } let prefix = url.match(/\?/) ? "&" : "?"; return `${url}${prefix}${this.serialize(params)}`; } }; // js/phoenix/longpoll.js var arrayBufferToBase64 = (buffer) => { let binary = ""; let bytes = new Uint8Array(buffer); let len = bytes.byteLength; for (let i = 0; i < len; i++) { binary += String.fromCharCode(bytes[i]); } return btoa(binary); }; var LongPoll = class { constructor(endPoint, protocols) { if (protocols && protocols.length === 2 && protocols[1].startsWith(AUTH_TOKEN_PREFIX)) { this.authToken = atob(protocols[1].slice(AUTH_TOKEN_PREFIX.length)); } this.endPoint = null; this.token = null; this.skipHeartbeat = true; this.reqs = /* @__PURE__ */ new Set(); this.awaitingBatchAck = false; this.currentBatch = null; this.currentBatchTimer = null; this.batchBuffer = []; this.onopen = function() { }; this.onerror = function() { }; this.onmessage = function() { }; this.onclose = function() { }; this.pollEndpoint = this.normalizeEndpoint(endPoint); this.readyState = SOCKET_STATES.connecting; setTimeout(() => this.poll(), 0); } normalizeEndpoint(endPoint) { return endPoint.replace("ws://", "http://").replace("wss://", "https://").replace(new RegExp("(.*)/" + TRANSPORTS.websocket), "$1/" + TRANSPORTS.longpoll); } endpointURL() { return Ajax.appendParams(this.pollEndpoint, { token: this.token }); } closeAndRetry(code, reason, wasClean) { this.close(code, reason, wasClean); this.readyState = SOCKET_STATES.connecting; } ontimeout() { this.onerror("timeout"); this.closeAndRetry(1005, "timeout", false); } isActive() { return this.readyState === SOCKET_STATES.open || this.readyState === SOCKET_STATES.connecting; } poll() { const headers = { "Accept": "application/json" }; if (this.authToken) { headers["X-Phoenix-AuthToken"] = this.authToken; } this.ajax("GET", headers, null, () => this.ontimeout(), (resp) => { if (resp) { var { status, token, messages } = resp; if (status === 410 && this.token !== null) { this.onerror(410); this.closeAndRetry(3410, "session_gone", false); return; } this.token = token; } else { status = 0; } switch (status) { case 200: messages.forEach((msg) => { setTimeout(() => this.onmessage({ data: msg }), 0); }); this.poll(); break; case 204: this.poll(); break; case 410: this.readyState = SOCKET_STATES.open; this.onopen({}); this.poll(); break; case 403: this.onerror(403); this.close(1008, "forbidden", false); break; case 0: case 500: this.onerror(500); this.closeAndRetry(1011, "internal server error", 500); break; default: throw new Error(`unhandled poll status ${status}`); } }); } // we collect all pushes within the current event loop by // setTimeout 0, which optimizes back-to-back procedural // pushes against an empty buffer send(body) { if (typeof body !== "string") { body = arrayBufferToBase64(body); } if (this.currentBatch) { this.currentBatch.push(body); } else if (this.awaitingBatchAck) { this.batchBuffer.push(body); } else { this.currentBatch = [body]; this.currentBatchTimer = setTimeout(() => { this.batchSend(this.currentBatch); this.currentBatch = null; }, 0); } } batchSend(messages) { this.awaitingBatchAck = true; this.ajax("POST", { "Content-Type": "application/x-ndjson" }, messages.join("\n"), () => this.onerror("timeout"), (resp) => { this.awaitingBatchAck = false; if (!resp || resp.status !== 200) { this.onerror(resp && resp.status); this.closeAndRetry(1011, "internal server error", false); } else if (this.batchBuffer.length > 0) { this.batchSend(this.batchBuffer); this.batchBuffer = []; } }); } close(code, reason, wasClean) { for (let req of this.reqs) { req.abort(); } this.readyState = SOCKET_STATES.closed; let opts = Object.assign({ code: 1e3, reason: void 0, wasClean: true }, { code, reason, wasClean }); this.batchBuffer = []; clearTimeout(this.currentBatchTimer); this.currentBatchTimer = null; if (typeof CloseEvent !== "undefined") { this.onclose(new CloseEvent("close", opts)); } else { this.onclose(opts); } } ajax(method, headers, body, onCallerTimeout, callback) { let req; let ontimeout = () => { this.reqs.delete(req); onCallerTimeout(); }; req = Ajax.request(method, this.endpointURL(), headers, body, this.timeout, ontimeout, (resp) => { this.reqs.delete(req); if (this.isActive()) { callback(resp); } }); this.reqs.add(req); } }; // js/phoenix/presence.js var Presence = class _Presence { constructor(channel, opts = {}) { let events = opts.events || { state: "presence_state", diff: "presence_diff" }; this.state = {}; this.pendingDiffs = []; this.channel = channel; this.joinRef = null; this.caller = { onJoin: function() { }, onLeave: function() { }, onSync: function() { } }; this.channel.on(events.state, (newState) => { let { onJoin, onLeave, onSync } = this.caller; this.joinRef = this.channel.joinRef(); this.state = _Presence.syncState(this.state, newState, onJoin, onLeave); this.pendingDiffs.forEach((diff) => { this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave); }); this.pendingDiffs = []; onSync(); }); this.channel.on(events.diff, (diff) => { let { onJoin, onLeave, onSync } = this.caller; if (this.inPendingSyncState()) { this.pendingDiffs.push(diff); } else { this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave); onSync(); } }); } onJoin(callback) { this.caller.onJoin = callback; } onLeave(callback) { this.caller.onLeave = callback; } onSync(callback) { this.caller.onSync = callback; } list(by) { return _Presence.list(this.state, by); } inPendingSyncState() { return !this.joinRef || this.joinRef !== this.channel.joinRef(); } // lower-level public static API /** * Used to sync the list of presences on the server * with the client's state. An optional `onJoin` and `onLeave` callback can * be provided to react to changes in the client's local presences across * disconnects and reconnects with the server. * * @returns {Presence} */ static syncState(currentState, newState, onJoin, onLeave) { let state = this.clone(currentState); let joins = {}; let leaves = {}; this.map(state, (key, presence) => { if (!newState[key]) { leaves[key] = presence; } }); this.map(newState, (key, newPresence) => { let currentPresence = state[key]; if (currentPresence) { let newRefs = newPresence.metas.map((m) => m.phx_ref); let curRefs = currentPresence.metas.map((m) => m.phx_ref); let joinedMetas = newPresence.metas.filter((m) => curRefs.indexOf(m.phx_ref) < 0); let leftMetas = currentPresence.metas.filter((m) => newRefs.indexOf(m.phx_ref) < 0); if (joinedMetas.length > 0) { joins[key] = newPresence; joins[key].metas = joinedMetas; } if (leftMetas.length > 0) { leaves[key] = this.clone(currentPresence); leaves[key].metas = leftMetas; } } else { joins[key] = newPresence; } }); return this.syncDiff(state, { joins, leaves }, onJoin, onLeave); } /** * * Used to sync a diff of presence join and leave * events from the server, as they happen. Like `syncState`, `syncDiff` * accepts optional `onJoin` and `onLeave` callbacks to react to a user * joining or leaving from a device. * * @returns {Presence} */ static syncDiff(state, diff, onJoin, onLeave) { let { joins, leaves } = this.clone(diff); if (!onJoin) { onJoin = function() { }; } if (!onLeave) { onLeave = function() { }; } this.map(joins, (key, newPresence) => { let currentPresence = state[key]; state[key] = this.clone(newPresence); if (currentPresence) { let joinedRefs = state[key].metas.map((m) => m.phx_ref); let curMetas = currentPresence.metas.filter((m) => joinedRefs.indexOf(m.phx_ref) < 0); state[key].metas.unshift(...curMetas); } onJoin(key, currentPresence, newPresence); }); this.map(leaves, (key, leftPresence) => { let currentPresence = state[key]; if (!currentPresence) { return; } let refsToRemove = leftPresence.metas.map((m) => m.phx_ref); currentPresence.metas = currentPresence.metas.filter((p) => { return refsToRemove.indexOf(p.phx_ref) < 0; }); onLeave(key, currentPresence, leftPresence); if (currentPresence.metas.length === 0) { delete state[key]; } }); return state; } /** * Returns the array of presences, with selected metadata. * * @param {Object} presences * @param {Function} chooser * * @returns {Presence} */ static list(presences, chooser) { if (!chooser) { chooser = function(key, pres) { return pres; }; } return this.map(presences, (key, presence) => { return chooser(key, presence); }); } // private static map(obj, func) { return Object.getOwnPropertyNames(obj).map((key) => func(key, obj[key])); } static clone(obj) { return JSON.parse(JSON.stringify(obj)); } }; // js/phoenix/serializer.js var serializer_default = { HEADER_LENGTH: 1, META_LENGTH: 4, KINDS: { push: 0, reply: 1, broadcast: 2 }, encode(msg, callback) { if (msg.payload.constructor === ArrayBuffer) { return callback(this.binaryEncode(msg)); } else { let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload]; return callback(JSON.stringify(payload)); } }, decode(rawPayload, callback) { if (rawPayload.constructor === ArrayBuffer) { return callback(this.binaryDecode(rawPayload)); } else { let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload); return callback({ join_ref, ref, topic, event, payload }); } }, // private binaryEncode(message) { let { join_ref, ref, event, topic, payload } = message; let metaLength = this.META_LENGTH + join_ref.length + ref.length + topic.length + event.length; let header = new ArrayBuffer(this.HEADER_LENGTH + metaLength); let view = new DataView(header); let offset = 0; view.setUint8(offset++, this.KINDS.push); view.setUint8(offset++, join_ref.length); view.setUint8(offset++, ref.length); view.setUint8(offset++, topic.length); view.setUint8(offset++, event.length); Array.from(join_ref, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(ref, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(topic, (char) => view.setUint8(offset++, char.charCodeAt(0))); Array.from(event, (char) => view.setUint8(offset++, char.charCodeAt(0))); var combined = new Uint8Array(header.byteLength + payload.byteLength); combined.set(new Uint8Array(header), 0); combined.set(new Uint8Array(payload), header.byteLength); return combined.buffer; }, binaryDecode(buffer) { let view = new DataView(buffer); let kind = view.getUint8(0); let decoder = new TextDecoder(); switch (kind) { case this.KINDS.push: return this.decodePush(buffer, view, decoder); case this.KINDS.reply: return this.decodeReply(buffer, view, decoder); case this.KINDS.broadcast: return this.decodeBroadcast(buffer, view, decoder); } }, decodePush(buffer, view, decoder) { let joinRefSize = view.getUint8(1); let topicSize = view.getUint8(2); let eventSize = view.getUint8(3); let offset = this.HEADER_LENGTH + this.META_LENGTH - 1; let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)); offset = offset + joinRefSize; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); return { join_ref: joinRef, ref: null, topic, event, payload: data }; }, decodeReply(buffer, view, decoder) { let joinRefSize = view.getUint8(1); let refSize = view.getUint8(2); let topicSize = view.getUint8(3); let eventSize = view.getUint8(4); let offset = this.HEADER_LENGTH + this.META_LENGTH; let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize)); offset = offset + joinRefSize; let ref = decoder.decode(buffer.slice(offset, offset + refSize)); offset = offset + refSize; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); let payload = { status: event, response: data }; return { join_ref: joinRef, ref, topic, event: CHANNEL_EVENTS.reply, payload }; }, decodeBroadcast(buffer, view, decoder) { let topicSize = view.getUint8(1); let eventSize = view.getUint8(2); let offset = this.HEADER_LENGTH + 2; let topic = decoder.decode(buffer.slice(offset, offset + topicSize)); offset = offset + topicSize; let event = decoder.decode(buffer.slice(offset, offset + eventSize)); offset = offset + eventSize; let data = buffer.slice(offset, buffer.byteLength); return { join_ref: null, ref: null, topic, event, payload: data }; } }; // js/phoenix/socket.js var Socket = class { constructor(endPoint, opts = {}) { this.stateChangeCallbacks = { open: [], close: [], error: [], message: [] }; this.channels = []; this.sendBuffer = []; this.ref = 0; this.fallbackRef = null; this.timeout = opts.timeout || DEFAULT_TIMEOUT; this.transport = opts.transport || global.WebSocket || LongPoll; this.primaryPassedHealthCheck = false; this.longPollFallbackMs = opts.longPollFallbackMs; this.fallbackTimer = null; this.sessionStore = opts.sessionStorage || global && global.sessionStorage; this.establishedConnections = 0; this.defaultEncoder = serializer_default.encode.bind(serializer_default); this.defaultDecoder = serializer_default.decode.bind(serializer_default); this.closeWasClean = true; this.disconnecting = false; this.binaryType = opts.binaryType || "arraybuffer"; this.connectClock = 1; this.pageHidden = false; if (this.transport !== LongPoll) { this.encode = opts.encode || this.defaultEncoder; this.decode = opts.decode || this.defaultDecoder; } else { this.encode = this.defaultEncoder; this.decode = this.defaultDecoder; } let awaitingConnectionOnPageShow = null; if (phxWindow && phxWindow.addEventListener) { phxWindow.addEventListener("pagehide", (_e) => { if (this.conn) { this.disconnect(); awaitingConnectionOnPageShow = this.connectClock; } }); phxWindow.addEventListener("pageshow", (_e) => { if (awaitingConnectionOnPageShow === this.connectClock) { awaitingConnectionOnPageShow = null; this.connect(); } }); phxWindow.addEventListener("visibilitychange", () => { if (document.visibilityState === "hidden") { this.pageHidden = true; } else { this.pageHidden = false; if (!this.isConnected() && !this.closeWasClean) { this.teardown(() => this.connect()); } } }); } this.heartbeatIntervalMs = opts.heartbeatIntervalMs || 3e4; this.rejoinAfterMs = (tries) => { if (opts.rejoinAfterMs) { return opts.rejoinAfterMs(tries); } else { return [1e3, 2e3, 5e3][tries - 1] || 1e4; } }; this.reconnectAfterMs = (tries) => { if (opts.reconnectAfterMs) { return opts.reconnectAfterMs(tries); } else { return [10, 50, 100, 150, 200, 250, 500, 1e3, 2e3][tries - 1] || 5e3; } }; this.logger = opts.logger || null; if (!this.logger && opts.debug) { this.logger = (kind, msg, data) => { console.log(`${kind}: ${msg}`, data); }; } this.longpollerTimeout = opts.longpollerTimeout || 2e4; this.params = closure(opts.params || {}); this.endPoint = `${endPoint}/${TRANSPORTS.websocket}`; this.vsn = opts.vsn || DEFAULT_VSN; this.heartbeatTimeoutTimer = null; this.heartbeatTimer = null; this.pendingHeartbeatRef = null; this.reconnectTimer = new Timer(() => { if (this.pageHidden) { this.log("Not reconnecting as page is hidden!"); this.teardown(); return; } this.teardown(() => this.connect()); }, this.reconnectAfterMs); this.authToken = opts.authToken; } /** * Returns the LongPoll transport reference */ getLongPollTransport() { return LongPoll; } /** * Disconnects and replaces the active transport * * @param {Function} newTransport - The new transport class to instantiate * */ replaceTransport(newTransport) { this.connectClock++; this.closeWasClean = true; clearTimeout(this.fallbackTimer); this.reconnectTimer.reset(); if (this.conn) { this.conn.close(); this.conn = null; } this.transport = newTransport; } /** * Returns the socket protocol * * @returns {string} */ protocol() { return location.protocol.match(/^https/) ? "wss" : "ws"; } /** * The fully qualified socket url * * @returns {string} */ endPointURL() { let uri = Ajax.appendParams( Ajax.appendParams(this.endPoint, this.params()), { vsn: this.vsn } ); if (uri.charAt(0) !== "/") { return uri; } if (uri.charAt(1) === "/") { return `${this.protocol()}:${uri}`; } return `${this.protocol()}://${location.host}${uri}`; } /** * Disconnects the socket * * See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes for valid status codes. * * @param {Function} callback - Optional callback which is called after socket is disconnected. * @param {integer} code - A status code for disconnection (Optional). * @param {string} reason - A textual description of the reason to disconnect. (Optional) */ disconnect(callback, code, reason) { this.connectClock++; this.disconnecting = true; this.closeWasClean = true; clearTimeout(this.fallbackTimer); this.reconnectTimer.reset(); this.teardown(() => { this.disconnecting = false; callback && callback(); }, code, reason); } /** * * @param {Object} params - The params to send when connecting, for example `{user_id: userToken}` * * Passing params to connect is deprecated; pass them in the Socket constructor instead: * `new Socket("/socket", {params: {user_id: userToken}})`. */ connect(params) { if (params) { console && console.log("passing params to connect is deprecated. Instead pass :params to the Socket constructor"); this.params = closure(params); } if (this.conn && !this.disconnecting) { return; } if (this.longPollFallbackMs && this.transport !== LongPoll) { this.connectWithFallback(LongPoll, this.longPollFallbackMs); } else { this.transportConnect(); } } /** * Logs the message. Override `this.logger` for specialized logging. noops by default * @param {string} kind * @param {string} msg * @param {Object} data */ log(kind, msg, data) { this.logger && this.logger(kind, msg, data); } /** * Returns true if a logger has been set on this socket. */ hasLogger() { return this.logger !== null; } /** * Registers callbacks for connection open events * * @example socket.onOpen(function(){ console.info("the socket was opened") }) * * @param {Function} callback */ onOpen(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.open.push([ref, callback]); return ref; } /** * Registers callbacks for connection close events * @param {Function} callback */ onClose(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.close.push([ref, callback]); return ref; } /** * Registers callbacks for connection error events * * @example socket.onError(function(error){ alert("An error occurred") }) * * @param {Function} callback */ onError(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.error.push([ref, callback]); return ref; } /** * Registers callbacks for connection message events * @param {Function} callback */ onMessage(callback) { let ref = this.makeRef(); this.stateChangeCallbacks.message.push([ref, callback]); return ref; } /** * Pings the server and invokes the callback with the RTT in milliseconds * @param {Function} callback * * Returns true if the ping was pushed or false if unable to be pushed. */ ping(callback) { if (!this.isConnected()) { return false; } let ref = this.makeRef(); let startTime = Date.now(); this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref }); let onMsgRef = this.onMessage((msg) => { if (msg.ref === ref) { this.off([onMsgRef]); callback(Date.now() - startTime); } }); return true; } /** * @private * * @param {Function} */ transportName(transport) { switch (transport) { case LongPoll: return "LongPoll"; default: return transport.name; } } /** * @private */ transportConnect() { this.connectClock++; this.closeWasClean = false; let protocols = void 0; if (this.authToken) { protocols = ["phoenix", `${AUTH_TOKEN_PREFIX}${btoa(this.authToken).replace(/=/g, "")}`]; } this.conn = new this.transport(this.endPointURL(), protocols); this.conn.binaryType = this.binaryType; this.conn.timeout = this.longpollerTimeout; this.conn.onopen = () => this.onConnOpen(); this.conn.onerror = (error) => this.onConnError(error); this.conn.onmessage = (event) => this.onConnMessage(event); this.conn.onclose = (event) => this.onConnClose(event); } getSession(key) { return this.sessionStore && this.sessionStore.getItem(key); } storeSession(key, val) { this.sessionStore && this.sessionStore.setItem(key, val); } connectWithFallback(fallbackTransport, fallbackThreshold = 2500) { clearTimeout(this.fallbackTimer); let established = false; let primaryTransport = true; let openRef, errorRef; let fallbackTransportName = this.transportName(fallbackTransport); let fallback = (reason) => { this.log("transport", `falling back to ${fallbackTransportName}...`, reason); this.off([openRef, errorRef]); primaryTransport = false; this.replaceTransport(fallbackTransport); this.transportConnect(); }; if (this.getSession(`phx:fallback:${fallbackTransportName}`)) { return fallback("memorized"); } this.fallbackTimer = setTimeout(fallback, fallbackThreshold); errorRef = this.onError((reason) => { this.log("transport", "error", reason); if (primaryTransport && !established) { clearTimeout(this.fallbackTimer); fallback(reason); } }); if (this.fallbackRef) { this.off([this.fallbackRef]); } this.fallbackRef = this.onOpen(() => { established = true; if (!primaryTransport) { let fallbackTransportName2 = this.transportName(fallbackTransport); if (!this.primaryPassedHealthCheck) { this.storeSession(`phx:fallback:${fallbackTransportName2}`, "true"); } return this.log("transport", `established ${fallbackTransportName2} fallback`); } clearTimeout(this.fallbackTimer); this.fallbackTimer = setTimeout(fallback, fallbackThreshold); this.ping((rtt) => { this.log("transport", "connected to primary after", rtt); this.primaryPassedHealthCheck = true; clearTimeout(this.fallbackTimer); }); }); this.transportConnect(); } clearHeartbeats() { clearTimeout(this.heartbeatTimer); clearTimeout(this.heartbeatTimeoutTimer); } onConnOpen() { if (this.hasLogger()) this.log("transport", `${this.transportName(this.transport)} connected to ${this.endPointURL()}`); this.closeWasClean = false; this.disconnecting = false; this.establishedConnections++; this.flushSendBuffer(); this.reconnectTimer.reset(); this.resetHeartbeat(); this.stateChangeCallbacks.open.forEach(([, callback]) => callback()); } /** * @private */ heartbeatTimeout() { if (this.pendingHeartbeatRef) { this.pendingHeartbeatRef = null; if (this.hasLogger()) { this.log("transport", "heartbeat timeout. Attempting to re-establish connection"); } this.triggerChanError(); this.closeWasClean = false; this.teardown(() => this.reconnectTimer.scheduleTimeout(), WS_CLOSE_NORMAL, "heartbeat timeout"); } } resetHeartbeat() { if (this.conn && this.conn.skipHeartbeat) { return; } this.pendingHeartbeatRef = null; this.clearHeartbeats(); this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs); } teardown(callback, code, reason) { if (!this.conn) { return callback && callback(); } const connToClose = this.conn; this.waitForBufferDone(connToClose, () => { if (code) { connToClose.close(code, reason || ""); } else { connToClose.close(); } this.waitForSocketClosed(connToClose, () => { if (this.conn === connToClose) { this.conn.onopen = function() { }; this.conn.onerror = function() { }; this.conn.onmessage = function() { }; this.conn.onclose = function() { }; this.conn = null; } callback && callback(); }); }); } waitForBufferDone(conn, callback, tries = 1) { if (tries === 5 || !conn.bufferedAmount) { callback(); return; } setTimeout(() => { this.waitForBufferDone(conn, callback, tries + 1); }, 150 * tries); } waitForSocketClosed(conn, callback, tries = 1) { if (tries === 5 || conn.readyState === SOCKET_STATES.closed) { callback(); return; } setTimeout(() => { this.waitForSocketClosed(conn, callback, tries + 1); }, 150 * tries); } onConnClose(event) { if (this.conn) this.conn.onclose = () => { }; let closeCode = event && event.code; if (this.hasLogger()) this.log("transport", "close", event); this.triggerChanError(); this.clearHeartbeats(); if (!this.closeWasClean && closeCode !== 1e3) { this.reconnectTimer.scheduleTimeout(); } this.stateChangeCallbacks.close.forEach(([, callback]) => callback(event)); } /** * @private */ onConnError(error) { if (this.hasLogger()) this.log("transport", error); let transportBefore = this.transport; let establishedBefore = this.establishedConnections; this.stateChangeCallbacks.error.forEach(([, callback]) => { callback(error, transportBefore, establishedBefore); }); if (transportBefore === this.transport || establishedBefore > 0) { this.triggerChanError(); } } /** * @private */ triggerChanError() { this.channels.forEach((channel) => { if (!(channel.isErrored() || channel.isLeaving() || channel.isClosed())) { channel.trigger(CHANNEL_EVENTS.error); } }); } /** * @returns {string} */ connectionState() { switch (this.conn && this.conn.readyState) { case SOCKET_STATES.connecting: return "connecting"; case SOCKET_STATES.open: return "open"; case SOCKET_STATES.closing: return "closing"; default: return "closed"; } } /** * @returns {boolean} */ isConnected() { return this.connectionState() === "open"; } /** * @private * * @param {Channel} */ remove(channel) { this.off(channel.stateChangeRefs); this.channels = this.channels.filter((c) => c !== channel); } /** * Removes `onOpen`, `onClose`, `onError,` and `onMessage` registrations. * * @param {refs} - list of refs returned by calls to * `onOpen`, `onClose`, `onError,` and `onMessage` */ off(refs) { for (let key in this.stateChangeCallbacks) { this.stateChangeCallbacks[key] = this.stateChangeCallbacks[key].filter(([ref]) => { return refs.indexOf(ref) === -1; }); } } /** * Initiates a new channel for the given topic * * @param {string} topic * @param {Object} chanParams - Parameters for the channel * @returns {Channel} */ channel(topic, chanParams = {}) { let chan = new Channel(topic, chanParams, this); this.channels.push(chan); return chan; } /** * @param {Object} data */ push(data) { if (this.hasLogger()) { let { topic, event, payload, ref, join_ref } = data; this.log("push", `${topic} ${event} (${join_ref}, ${ref})`, payload); } if (this.isConnected()) { this.encode(data, (result) => this.conn.send(result)); } else { this.sendBuffer.push(() => this.encode(data, (result) => this.conn.send(result))); } } /** * Return the next message ref, accounting for overflows * @returns {string} */ makeRef() { let newRef = this.ref + 1; if (newRef === this.ref) { this.ref = 0; } else { this.ref = newRef; } return this.ref.toString(); } sendHeartbeat() { if (this.pendingHeartbeatRef && !this.isConnected()) { return; } this.pendingHeartbeatRef = this.makeRef(); this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref: this.pendingHeartbeatRef }); this.heartbeatTimeoutTimer = setTimeout(() => this.heartbeatTimeout(), this.heartbeatIntervalMs); } flushSendBuffer() { if (this.isConnected() && this.sendBuffer.length > 0) { this.sendBuffer.forEach((callback) => callback()); this.sendBuffer = []; } } onConnMessage(rawMessage) { this.decode(rawMessage.data, (msg) => { let { topic, event, payload, ref, join_ref } = msg; if (ref && ref === this.pendingHeartbeatRef) { this.clearHeartbeats(); this.pendingHeartbeatRef = null; this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs); } if (this.hasLogger()) this.log("receive", `${payload.status || ""} ${topic} ${event} ${ref && "(" + ref + ")" || ""}`, payload); for (let i = 0; i < this.channels.length; i++) { const channel = this.channels[i]; if (!channel.isMember(topic, event, payload, join_ref)) { continue; } channel.trigger(event, payload, ref, join_ref); } for (let i = 0; i < this.stateChangeCallbacks.message.length; i++) { let [, callback] = this.stateChangeCallbacks.message[i]; callback(msg); } }); } leaveOpenTopic(topic) { let dupChannel = this.channels.find((c) => c.topic === topic && (c.isJoined() || c.isJoining())); if (dupChannel) { if (this.hasLogger()) this.log("transport", `leaving duplicate topic "${topic}"`); dupChannel.leave(); } } }; export { Channel, LongPoll, Presence, serializer_default as Serializer, Socket }; //# sourceMappingURL=phoenix.mjs.map ================================================ FILE: priv/templates/phx.gen.auth/AGENTS.md.eex ================================================ ## Authentication - **Always** handle authentication flow at the router level with proper redirects - **Always** be mindful of where to place routes. `phx.gen.auth` creates multiple router plugs<%= if live? do %> and `live_session` scopes<% end %>: - A plug `:fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>` that is included in the default browser pipeline - A plug `:require_authenticated_<%= schema.singular %>` that redirects to the log in page when the <%= schema.singular %> is not authenticated<%= if live? do %> - A `live_session :current_<%= schema.singular %>` scope - for routes that need the current <%= schema.singular %> but don't require authentication, similar to `:fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>` - A `live_session :require_authenticated_<%= schema.singular %>` scope - for routes that require authentication, similar to the plug with the same name<% end %> - In both cases, a `@<%= scope_config.scope.assign_key %>` is assigned to the Plug connection<%= if live? do %> and LiveView socket<% end %> - A plug `redirect_if_<%= schema.singular %>_is_authenticated` that redirects to a default path in case the <%= schema.singular %> is authenticated - useful for a registration page that should only be shown to unauthenticated <%= schema.plural %> - **Always let the user know in which router scopes<%= if live? do%>, `live_session`,<% end %> and pipeline you are placing the route, AND SAY WHY** - `phx.gen.auth` assigns the `<%= scope_config.scope.assign_key %>` assign - it **does not assign a `current_<%= schema.singular %>` assign** - Always pass the assign `<%= scope_config.scope.assign_key %>` to context modules as first argument. When performing queries, use `<%= scope_config.scope.assign_key %>.<%= schema.singular %>` to filter the query results - To derive/access `current_<%= schema.singular %>` in templates, **always use the `@<%= scope_config.scope.assign_key %>.<%= schema.singular %>`**, never use **`@current_<%= schema.singular %>`** in templates<%= if live? do %> or LiveViews - **Never** duplicate `live_session` names. A `live_session :current_<%= schema.singular %>` can only be defined __once__ in the router, so all routes for the `live_session :current_<%= schema.singular %>` must be grouped in a single block<% end %> - Anytime you hit `<%= scope_config.scope.assign_key %>` errors or the logged in session isn't displaying the right content, **always double check the router and ensure you are using the correct plug<%= if live? do %> and `live_session`<% end %> as described below** ### Routes that require authentication <%= if live? do %>LiveViews that require login should **always be placed inside the __existing__ `live_session :require_authenticated_<%= schema.singular %>` block**: scope "/", AppWeb do pipe_through [:browser, :require_authenticated_<%= schema.singular %>] live_session :require_authenticated_<%= schema.singular %>, on_mount: [{<%= inspect auth_module %>, :require_authenticated}] do # phx.gen.auth generated routes live "/<%= schema.plural %>/settings", <%= inspect schema.alias %>Live.Settings, :edit live "/<%= schema.plural %>/settings/confirm-email/:token", <%= inspect schema.alias %>Live.Settings, :confirm_email # our own routes that require logged in <%= schema.singular %> live "/", MyLiveThatRequiresAuth, :index end end <% end %>Controller routes must be placed in a scope that sets the `:require_authenticated_<%= schema.singular %>` plug: scope "/", AppWeb do pipe_through [:browser, :require_authenticated_<%= schema.singular %>] get "/", MyControllerThatRequiresAuth, :index end ### Routes that work with or without authentication <%= if live? do %>LiveViews that can work with or without authentication, **always use the __existing__ `:current_<%= schema.singular %>` scope**, ie: scope "/", MyAppWeb do pipe_through [:browser] live_session :current_<%= schema.singular %>, on_mount: [{<%= inspect auth_module %>, :mount_<%= scope_config.scope.assign_key %>}] do # our own routes that work with or without authentication live "/", PublicLive end end <% end %>Controllers automatically have the `<%= scope_config.scope.assign_key %>` available if they use the `:browser` pipeline. ================================================ FILE: priv/templates/phx.gen.auth/auth.ex.eex ================================================ defmodule <%= inspect auth_module %> do use <%= inspect context.web_module %>, :verified_routes import Plug.Conn import Phoenix.Controller alias <%= inspect context.module %> alias <%= inspect scope_config.scope.module %> # Make the remember me cookie valid for 14 days. This should match # the session validity setting in <%= inspect schema.alias %>Token. @max_cookie_age_in_days 14 @remember_me_cookie "_<%= web_app_name %>_<%= schema.singular %>_remember_me" @remember_me_options [ sign: true, max_age: @max_cookie_age_in_days * 24 * 60 * 60, same_site: "Lax" ] # How old the session token should be before a new one is issued. When a request is made # with a session token older than this value, then a new session token will be created # and the session and remember-me cookies (if set) will be updated with the new token. # Lowering this value will result in more tokens being created by active users. Increasing # it will result in less time before a session token expires for a user to get issued a new # token. This can be set to a value greater than `@max_cookie_age_in_days` to disable # the reissuing of tokens completely. @session_reissue_age_in_days 7 @doc """ Logs the <%= schema.singular %> in. Redirects to the session's `:<%= schema.singular %>_return_to` path or falls back to the `signed_in_path/1`. """ def log_in_<%= schema.singular %>(conn, <%= schema.singular %>, params \\ %{}) do <%= schema.singular %>_return_to = get_session(conn, :<%= schema.singular %>_return_to) conn |> create_or_extend_session(<%= schema.singular %>, params) |> redirect(to: <%= schema.singular %>_return_to || signed_in_path(conn)) end @doc """ Logs the <%= schema.singular %> out. It clears all session data for safety. See renew_session. """ def log_out_<%= schema.singular %>(conn) do <%= schema.singular %>_token = get_session(conn, :<%= schema.singular %>_token) <%= schema.singular %>_token && <%= inspect context.alias %>.delete_<%= schema.singular %>_session_token(<%= schema.singular %>_token) if live_socket_id = get_session(conn, :live_socket_id) do <%= inspect(endpoint_module) %>.broadcast(live_socket_id, "disconnect", %{}) end conn |> renew_session(nil) |> delete_resp_cookie(@remember_me_cookie, @remember_me_options) |> redirect(to: ~p"/") end @doc """ Authenticates the <%= schema.singular %> by looking into the session and remember me token. Will reissue the session token if it is older than the configured age. """ def fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>(conn, _opts) do with {token, conn} <- ensure_<%= schema.singular %>_token(conn), {<%= schema.singular %>, token_inserted_at} <- <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(token) do conn |> assign(:<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>)) |> maybe_reissue_<%= schema.singular %>_session_token(<%= schema.singular %>, token_inserted_at) else nil -> assign(conn, :<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(nil)) end end defp ensure_<%= schema.singular %>_token(conn) do if token = get_session(conn, :<%= schema.singular %>_token) do {token, conn} else conn = fetch_cookies(conn, signed: [@remember_me_cookie]) if token = conn.cookies[@remember_me_cookie] do {token, conn |> put_token_in_session(token) |> put_session(:<%= schema.singular %>_remember_me, true)} else nil end end end # Reissue the session token if it is older than the configured reissue age. defp maybe_reissue_<%= schema.singular %>_session_token(conn, <%= schema.singular %>, token_inserted_at) do token_age = <%= inspect datetime_module %>.diff(<%= datetime_now %>, token_inserted_at, :day) if token_age >= @session_reissue_age_in_days do create_or_extend_session(conn, <%= schema.singular %>, %{}) else conn end end # This function is the one responsible for creating session tokens # and storing them safely in the session and cookies. It may be called # either when logging in, during sudo mode, or to renew a session which # will soon expire. # # When the session is created, rather than extended, the renew_session # function will clear the session to avoid fixation attacks. See the # renew_session function to customize this behaviour. defp create_or_extend_session(conn, <%= schema.singular %>, params) do token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) remember_me = get_session(conn, :<%= schema.singular %>_remember_me) conn |> renew_session(<%= schema.singular %>) |> put_token_in_session(token) |> maybe_write_remember_me_cookie(token, params, remember_me) end # Do not renew session if the <%= schema.singular %> is already logged in # to prevent CSRF errors or data being lost in tabs that are still open defp renew_session(conn, <%= schema.singular %>) when conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.id == <%= schema.singular %>.id do conn end # This function renews the session ID and erases the whole # session to avoid fixation attacks. If there is any data # in the session you may want to preserve after log in/log out, # you must explicitly fetch the session data before clearing # and then immediately set it after clearing, for example: # # defp renew_session(conn, _<%= schema.singular %>) do # delete_csrf_token() # preferred_locale = get_session(conn, :preferred_locale) # # conn # |> configure_session(renew: true) # |> clear_session() # |> put_session(:preferred_locale, preferred_locale) # end # defp renew_session(conn, _<%= schema.singular %>) do delete_csrf_token() conn |> configure_session(renew: true) |> clear_session() end defp maybe_write_remember_me_cookie(conn, token, %{"remember_me" => "true"}, _), do: write_remember_me_cookie(conn, token) defp maybe_write_remember_me_cookie(conn, token, _params, true), do: write_remember_me_cookie(conn, token) defp maybe_write_remember_me_cookie(conn, _token, _params, _), do: conn defp write_remember_me_cookie(conn, token) do conn |> put_session(:<%= schema.singular %>_remember_me, true) |> put_resp_cookie(@remember_me_cookie, token, @remember_me_options) end <%= if live? do %>defp put_token_in_session(conn, token) do conn |> put_session(:<%= schema.singular %>_token, token) |> put_session(:live_socket_id, <%= schema.singular %>_session_topic(token)) end @doc """ Disconnects existing sockets for the given tokens. """ def disconnect_sessions(tokens) do Enum.each(tokens, fn %{token: token} -> <%= inspect endpoint_module %>.broadcast(<%= schema.singular %>_session_topic(token), "disconnect", %{}) end) end defp <%= schema.singular %>_session_topic(token), do: "<%= schema.plural %>_sessions:#{Base.url_encode64(token)}" @doc """ Handles mounting and authenticating the <%= scope_config.scope.assign_key %> in LiveViews. ## `on_mount` arguments * `:mount_<%= scope_config.scope.assign_key %>` - Assigns <%= scope_config.scope.assign_key %> to socket assigns based on <%= schema.singular %>_token, or nil if there's no <%= schema.singular %>_token or no matching <%= schema.singular %>. * `:require_authenticated` - Authenticates the <%= schema.singular %> from the session, and assigns the <%= scope_config.scope.assign_key %> to socket assigns based on <%= schema.singular %>_token. Redirects to login page if there's no logged <%= schema.singular %>. ## Examples Use the `on_mount` lifecycle macro in LiveViews to mount or authenticate the `<%= scope_config.scope.assign_key %>`: defmodule <%= inspect context.web_module %>.PageLive do use <%= inspect context.web_module %>, :live_view on_mount {<%= inspect auth_module %>, :mount_<%= scope_config.scope.assign_key %>} ... end Or use the `live_session` of your router to invoke the on_mount callback: live_session :authenticated, on_mount: [{<%= inspect auth_module %>, :require_authenticated}] do live "/profile", ProfileLive, :index end """ def on_mount(:mount_<%= scope_config.scope.assign_key %>, _params, session, socket) do {:cont, mount_<%= scope_config.scope.assign_key %>(socket, session)} end def on_mount(:require_authenticated, _params, session, socket) do socket = mount_<%= scope_config.scope.assign_key %>(socket, session) if socket.assigns.<%= scope_config.scope.assign_key %> && socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> do {:cont, socket} else socket = socket |> Phoenix.LiveView.put_flash(:error, "You must log in to access this page.") |> Phoenix.LiveView.redirect(to: ~p"<%= schema.route_prefix %>/log-in") {:halt, socket} end end def on_mount(:require_sudo_mode, _params, session, socket) do socket = mount_<%= scope_config.scope.assign_key %>(socket, session) if <%= inspect context.alias %>.sudo_mode?(socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>, -10) do {:cont, socket} else socket = socket |> Phoenix.LiveView.put_flash(:error, "You must re-authenticate to access this page.") |> Phoenix.LiveView.redirect(to: ~p"<%= schema.route_prefix %>/log-in") {:halt, socket} end end defp mount_<%= scope_config.scope.assign_key %>(socket, session) do Phoenix.Component.assign_new(socket, :<%= scope_config.scope.assign_key %>, fn -> {<%= schema.singular %>, _} = if <%= schema.singular %>_token = session["<%= schema.singular %>_token"] do <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(<%= schema.singular %>_token) end || {nil, nil} <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>) end) end @doc "Returns the path to redirect to after log in." # the <%= schema.singular %> was already logged in, redirect to settings def signed_in_path(%Plug.Conn{assigns: %{<%= scope_config.scope.assign_key %>: %<%= inspect scope_config.scope.alias %>{<%= schema.singular %>: %<%= inspect context.alias %>.<%= inspect schema.alias %>{}}}}) do ~p"<%= schema.route_prefix %>/settings" end def signed_in_path(_), do: ~p"/" <% else %>defp put_token_in_session(conn, token) do put_session(conn, :<%= schema.singular %>_token, token) end @doc """ Plug for routes that require sudo mode. """ def require_sudo_mode(conn, _opts) do if <%= inspect context.alias %>.sudo_mode?(conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>, -10) do conn else conn |> put_flash(:error, "You must re-authenticate to access this page.") |> maybe_store_return_to() |> redirect(to: ~p"<%= schema.route_prefix %>/log-in") |> halt() end end @doc """ Plug for routes that require the <%= schema.singular %> to not be authenticated. """ def redirect_if_<%= schema.singular %>_is_authenticated(conn, _opts) do if conn.assigns.<%= scope_config.scope.assign_key %> do conn |> redirect(to: signed_in_path(conn)) |> halt() else conn end end defp signed_in_path(_conn), do: ~p"/" <% end %>@doc """ Plug for routes that require the <%= schema.singular %> to be authenticated. """ def require_authenticated_<%= schema.singular %>(conn, _opts) do if conn.assigns.<%= scope_config.scope.assign_key %> && conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> do conn else conn |> put_flash(:error, "You must log in to access this page.") |> maybe_store_return_to() |> redirect(to: ~p"<%= schema.route_prefix %>/log-in") |> halt() end end defp maybe_store_return_to(%{method: "GET"} = conn) do put_session(conn, :<%= schema.singular %>_return_to, current_path(conn)) end defp maybe_store_return_to(conn), do: conn end ================================================ FILE: priv/templates/phx.gen.auth/auth_test.exs.eex ================================================ defmodule <%= inspect auth_module %>Test do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> <%= if live? do %>alias Phoenix.LiveView <% end %>alias <%= inspect context.module %> alias <%= inspect context.module %>.<%= inspect scope_config.scope.alias %> alias <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Auth import <%= inspect context.module %>Fixtures @remember_me_cookie "_<%= web_app_name %>_<%= schema.singular %>_remember_me" @remember_me_cookie_max_age 60 * 60 * 24 * 14 setup %{conn: conn} do conn = conn |> Map.replace!(:secret_key_base, <%= inspect endpoint_module %>.config(:secret_key_base)) |> init_test_session(%{}) %{<%= schema.singular %>: %{<%= schema.singular %>_fixture() | authenticated_at: <%= datetime_now %>}, conn: conn} end describe "log_in_<%= schema.singular %>/3" do test "stores the <%= schema.singular %> token in the session", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(conn, <%= schema.singular %>) assert token = get_session(conn, :<%= schema.singular %>_token)<%= if live? do %> assert get_session(conn, :live_socket_id) == "<%= schema.plural %>_sessions:#{Base.url_encode64(token)}"<% end %> assert redirected_to(conn) == ~p"/" assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(token) end test "clears everything previously stored in the session", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> put_session(:to_be_removed, "value") |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>) refute get_session(conn, :to_be_removed) end test "keeps session when re-authenticating", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> assign(:<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>)) |> put_session(:to_be_removed, "value") |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>) assert get_session(conn, :to_be_removed) end test "clears session when <%= schema.singular %> does not match when re-authenticating", %{ conn: conn, <%= schema.singular %>: <%= schema.singular %> } do other_<%= schema.singular %> = <%= schema.singular %>_fixture() conn = conn |> assign(:<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(other_<%= schema.singular %>)) |> put_session(:to_be_removed, "value") |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>) refute get_session(conn, :to_be_removed) end test "redirects to the configured path", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> put_session(:<%= schema.singular %>_return_to, "/hello") |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>) assert redirected_to(conn) == "/hello" end test "writes a cookie if remember_me is configured", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> fetch_cookies() |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, %{"remember_me" => "true"}) assert get_session(conn, :<%= schema.singular %>_token) == conn.cookies[@remember_me_cookie] assert get_session(conn, :<%= schema.singular %>_remember_me) == true assert %{value: signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie] assert signed_token != get_session(conn, :<%= schema.singular %>_token) assert max_age == @remember_me_cookie_max_age end<%= if live? do %> test "redirects to settings when <%= schema.singular %> is already logged in", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> assign(:<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>)) |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>) assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/settings" end<% end %> test "writes a cookie if remember_me was set in previous session", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> fetch_cookies() |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, %{"remember_me" => "true"}) assert get_session(conn, :<%= schema.singular %>_token) == conn.cookies[@remember_me_cookie] assert get_session(conn, :<%= schema.singular %>_remember_me) == true conn = conn |> recycle() |> Map.replace!(:secret_key_base, <%= inspect endpoint_module %>.config(:secret_key_base)) |> fetch_cookies() |> init_test_session(%{<%= schema.singular %>_remember_me: true}) # the conn is already logged in and has the remember_me cookie set, # now we log in again and even without explicitly setting remember_me, # the cookie should be set again conn = conn |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, %{}) assert %{value: signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie] assert signed_token != get_session(conn, :<%= schema.singular %>_token) assert max_age == @remember_me_cookie_max_age assert get_session(conn, :<%= schema.singular %>_remember_me) == true end end describe "logout_<%= schema.singular %>/1" do test "erases session and cookies", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %>_token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) conn = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> put_req_cookie(@remember_me_cookie, <%= schema.singular %>_token) |> fetch_cookies() |> <%= inspect schema.alias %>Auth.log_out_<%= schema.singular %>() refute get_session(conn, :<%= schema.singular %>_token) refute conn.cookies[@remember_me_cookie] assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie] assert redirected_to(conn) == ~p"/" refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(<%= schema.singular %>_token) end <%= if live? do %>test "broadcasts to the given live_socket_id", %{conn: conn} do live_socket_id = "<%= schema.plural %>_sessions:abcdef-token" <%= inspect(endpoint_module) %>.subscribe(live_socket_id) conn |> put_session(:live_socket_id, live_socket_id) |> <%= inspect(schema.alias) %>Auth.log_out_<%= schema.singular %>() assert_receive %Phoenix.Socket.Broadcast{event: "disconnect", topic: ^live_socket_id} end <% end %>test "works even if <%= schema.singular %> is already logged out", %{conn: conn} do conn = conn |> fetch_cookies() |> <%= inspect schema.alias %>Auth.log_out_<%= schema.singular %>() refute get_session(conn, :<%= schema.singular %>_token) assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie] assert redirected_to(conn) == ~p"/" end end describe "fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>/2" do test "authenticates <%= schema.singular %> from session", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %>_token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) conn = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> <%= inspect schema.alias %>Auth.fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>([]) assert conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.id == <%= schema.singular %>.id assert conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.authenticated_at == <%= schema.singular %>.authenticated_at assert get_session(conn, :<%= schema.singular %>_token) == <%= schema.singular %>_token end test "authenticates <%= schema.singular %> from cookies", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do logged_in_conn = conn |> fetch_cookies() |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, %{"remember_me" => "true"}) <%= schema.singular %>_token = logged_in_conn.cookies[@remember_me_cookie] %{value: signed_token} = logged_in_conn.resp_cookies[@remember_me_cookie] conn = conn |> put_req_cookie(@remember_me_cookie, signed_token) |> <%= inspect schema.alias %>Auth.fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>([]) assert conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.id == <%= schema.singular %>.id assert conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.authenticated_at == <%= schema.singular %>.authenticated_at assert get_session(conn, :<%= schema.singular %>_token) == <%= schema.singular %>_token assert get_session(conn, :<%= schema.singular %>_remember_me)<%= if live? do %> assert get_session(conn, :live_socket_id) == "<%= schema.plural %>_sessions:#{Base.url_encode64(<%= schema.singular %>_token)}"<% end %> end test "does not authenticate if data is missing", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do _ = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) conn = <%= inspect schema.alias %>Auth.fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>(conn, []) refute get_session(conn, :<%= schema.singular %>_token) refute conn.assigns.<%= scope_config.scope.assign_key %> end test "reissues a new token after a few days and refreshes cookie", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do logged_in_conn = conn |> fetch_cookies() |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, %{"remember_me" => "true"}) token = logged_in_conn.cookies[@remember_me_cookie] %{value: signed_token} = logged_in_conn.resp_cookies[@remember_me_cookie] offset_<%= schema.singular %>_token(token, -10, :day) {<%= schema.singular %>, _} = <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(token) conn = conn |> put_session(:<%= schema.singular %>_token, token) |> put_session(:<%= schema.singular %>_remember_me, true) |> put_req_cookie(@remember_me_cookie, signed_token) |> <%= inspect schema.alias %>Auth.fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>([]) assert conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.id == <%= schema.singular %>.id assert conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.authenticated_at == <%= schema.singular %>.authenticated_at assert new_token = get_session(conn, :<%= schema.singular %>_token) assert new_token != token assert %{value: new_signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie] assert new_signed_token != signed_token assert max_age == @remember_me_cookie_max_age end end <%= if live? do %>describe "on_mount :mount_<%= scope_config.scope.assign_key %>" do setup %{conn: conn} do %{conn: <%= inspect schema.alias %>Auth.fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>(conn, [])} end test "assigns <%= scope_config.scope.assign_key %> based on a valid <%= schema.singular %>_token", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %>_token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) session = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> get_session() {:cont, updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:mount_<%= scope_config.scope.assign_key %>, %{}, session, %LiveView.Socket{}) assert updated_socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.id == <%= schema.singular %>.id end test "assigns nil to <%= scope_config.scope.assign_key %> assign if there isn't a valid <%= schema.singular %>_token", %{conn: conn} do <%= schema.singular %>_token = "invalid_token" session = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> get_session() {:cont, updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:mount_<%= scope_config.scope.assign_key %>, %{}, session, %LiveView.Socket{}) assert updated_socket.assigns.<%= scope_config.scope.assign_key %> == nil end test "assigns nil to <%= scope_config.scope.assign_key %> assign if there isn't a <%= schema.singular %>_token", %{conn: conn} do session = conn |> get_session() {:cont, updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:mount_<%= scope_config.scope.assign_key %>, %{}, session, %LiveView.Socket{}) assert updated_socket.assigns.<%= scope_config.scope.assign_key %> == nil end end describe "on_mount :require_authenticated" do test "authenticates <%= scope_config.scope.assign_key %> based on a valid <%= schema.singular %>_token", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %>_token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) session = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> get_session() {:cont, updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:require_authenticated, %{}, session, %LiveView.Socket{}) assert updated_socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>.id == <%= schema.singular %>.id end test "redirects to login page if there isn't a valid <%= schema.singular %>_token", %{conn: conn} do <%= schema.singular %>_token = "invalid_token" session = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> get_session() socket = %LiveView.Socket{ endpoint: <%= inspect context.web_module %>.Endpoint, assigns: %{__changed__: %{}, flash: %{}} } {:halt, updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:require_authenticated, %{}, session, socket) assert updated_socket.assigns.<%= scope_config.scope.assign_key %> == nil end test "redirects to login page if there isn't a <%= schema.singular %>_token", %{conn: conn} do session = conn |> get_session() socket = %LiveView.Socket{ endpoint: <%= inspect context.web_module %>.Endpoint, assigns: %{__changed__: %{}, flash: %{}} } {:halt, updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:require_authenticated, %{}, session, socket) assert updated_socket.assigns.<%= scope_config.scope.assign_key %> == nil end end describe "on_mount :require_sudo_mode" do test "allows <%= schema.plural %> that have authenticated in the last 10 minutes", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %>_token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) session = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> get_session() socket = %LiveView.Socket{ endpoint: <%= inspect(endpoint_module) %>, assigns: %{__changed__: %{}, flash: %{}} } assert {:cont, _updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:require_sudo_mode, %{}, session, socket) end test "redirects when authentication is too old", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do eleven_minutes_ago = <%= datetime_now %> |> <%= inspect datetime_module %>.add(-11, :minute) <%= schema.singular %> = %{<%= schema.singular %> | authenticated_at: eleven_minutes_ago} <%= schema.singular %>_token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) {<%= schema.singular %>, token_inserted_at} = <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(<%= schema.singular %>_token) assert <%= inspect datetime_module %>.compare(token_inserted_at, <%= schema.singular %>.authenticated_at) == :gt session = conn |> put_session(:<%= schema.singular %>_token, <%= schema.singular %>_token) |> get_session() socket = %LiveView.Socket{ endpoint: <%= inspect context.web_module %>.Endpoint, assigns: %{__changed__: %{}, flash: %{}} } assert {:halt, _updated_socket} = <%= inspect schema.alias %>Auth.on_mount(:require_sudo_mode, %{}, session, socket) end end<% else %>describe "require_sudo_mode/2" do test "allows <%= schema.plural %> that have authenticated in the last 10 minutes", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> fetch_flash() |> assign(:<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>)) |> <%= inspect schema.alias %>Auth.require_sudo_mode([]) refute conn.halted refute conn.status end test "redirects when authentication is too old", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do eleven_minutes_ago = <%= datetime_now %> |> <%= inspect datetime_module %>.add(-11, :minute) <%= schema.singular %> = %{<%= schema.singular %> | authenticated_at: eleven_minutes_ago} <%= schema.singular %>_token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) {<%= schema.singular %>, token_inserted_at} = <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(<%= schema.singular %>_token) assert <%= inspect datetime_module %>.compare(token_inserted_at, <%= schema.singular %>.authenticated_at) == :gt conn = conn |> fetch_flash() |> assign(:<%= scope_config.scope.assign_key %>, Scope.for_<%= schema.singular %>(<%= schema.singular %>)) |> <%= inspect schema.alias %>Auth.require_sudo_mode([]) assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" assert Phoenix.Flash.get(conn.assigns.flash, :error) == "You must re-authenticate to access this page." end end describe "redirect_if_<%= schema.singular %>_is_authenticated/2" do setup %{conn: conn} do %{conn: <%= inspect schema.alias %>Auth.fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>(conn, [])} end test "redirects if <%= schema.singular %> is authenticated", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> assign(:<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>)) |> <%= inspect schema.alias %>Auth.redirect_if_<%= schema.singular %>_is_authenticated([]) assert conn.halted assert redirected_to(conn) == ~p"/" end test "does not redirect if <%= schema.singular %> is not authenticated", %{conn: conn} do conn = <%= inspect schema.alias %>Auth.redirect_if_<%= schema.singular %>_is_authenticated(conn, []) refute conn.halted refute conn.status end end<% end %> describe "require_authenticated_<%= schema.singular %>/2" do setup %{conn: conn} do %{conn: <%= inspect schema.alias %>Auth.fetch_<%= scope_config.scope.assign_key %>_for_<%= schema.singular %>(conn, [])} end test "redirects if <%= schema.singular %> is not authenticated", %{conn: conn} do conn = conn |> fetch_flash() |> <%= inspect schema.alias %>Auth.require_authenticated_<%= schema.singular %>([]) assert conn.halted assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" assert Phoenix.Flash.get(conn.assigns.flash, :error) == "You must log in to access this page." end test "stores the path to redirect to on GET", %{conn: conn} do halted_conn = %{conn | path_info: ["foo"], query_string: ""} |> fetch_flash() |> <%= inspect schema.alias %>Auth.require_authenticated_<%= schema.singular %>([]) assert halted_conn.halted assert get_session(halted_conn, :<%= schema.singular %>_return_to) == "/foo" halted_conn = %{conn | path_info: ["foo"], query_string: "bar=baz"} |> fetch_flash() |> <%= inspect schema.alias %>Auth.require_authenticated_<%= schema.singular %>([]) assert halted_conn.halted assert get_session(halted_conn, :<%= schema.singular %>_return_to) == "/foo?bar=baz" halted_conn = %{conn | path_info: ["foo"], query_string: "bar", method: "POST"} |> fetch_flash() |> <%= inspect schema.alias %>Auth.require_authenticated_<%= schema.singular %>([]) assert halted_conn.halted refute get_session(halted_conn, :<%= schema.singular %>_return_to) end test "does not redirect if <%= schema.singular %> is authenticated", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> assign(:<%= scope_config.scope.assign_key %>, <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>)) |> <%= inspect schema.alias %>Auth.require_authenticated_<%= schema.singular %>([]) refute conn.halted refute conn.status end end<%= if live? do %> describe "disconnect_sessions/1" do test "broadcasts disconnect messages for each token" do tokens = [%{token: "token1"}, %{token: "token2"}] for %{token: token} <- tokens do <%= inspect context.web_module %>.Endpoint.subscribe("<%= schema.plural %>_sessions:#{Base.url_encode64(token)}") end <%= inspect schema.alias %>Auth.disconnect_sessions(tokens) assert_receive %Phoenix.Socket.Broadcast{ event: "disconnect", topic: "<%= schema.plural %>_sessions:dG9rZW4x" } assert_receive %Phoenix.Socket.Broadcast{ event: "disconnect", topic: "<%= schema.plural %>_sessions:dG9rZW4y" } end end<% end %> end ================================================ FILE: priv/templates/phx.gen.auth/confirmation_live.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.Confirmation do use <%= inspect context.web_module %>, :live_view alias <%= inspect context.module %> @impl true def render(assigns) do ~H""" ={@<%= scope_config.scope.assign_key %>}>
<.header>Welcome {@<%= schema.singular %>.email}
<.form :if={!@<%= schema.singular %>.confirmed_at} for={@form} id="confirmation_form" phx-mounted={JS.focus_first()} phx-submit="submit" action={~p"<%= schema.route_prefix %>/log-in?_action=confirmed"} phx-trigger-action={@trigger_submit} > <.button name={@form[:remember_me].name} value="true" phx-disable-with="Confirming..." class="btn btn-primary w-full" > Confirm and stay logged in <.button phx-disable-with="Confirming..." class="btn btn-primary btn-soft w-full mt-2"> Confirm and log in only this time <.form :if={@<%= schema.singular %>.confirmed_at} for={@form} id="login_form" phx-submit="submit" phx-mounted={JS.focus_first()} action={~p"<%= schema.route_prefix %>/log-in"} phx-trigger-action={@trigger_submit} > <%%= if @<%= scope_config.scope.assign_key %> do %> <.button phx-disable-with="Logging in..." class="btn btn-primary w-full"> Log in <%% else %> <.button name={@form[:remember_me].name} value="true" phx-disable-with="Logging in..." class="btn btn-primary w-full" > Keep me logged in on this device <.button phx-disable-with="Logging in..." class="btn btn-primary btn-soft w-full mt-2"> Log me in only this time <%% end %>

.confirmed_at} class="alert alert-outline mt-8"> Tip: If you prefer passwords, you can enable them in the <%= schema.singular %> settings.

""" end @impl true def mount(%{"token" => token}, _session, socket) do if <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>_by_magic_link_token(token) do form = to_form(%{"token" => token}, as: "<%= schema.singular %>") {:ok, assign(socket, <%= schema.singular %>: <%= schema.singular %>, form: form, trigger_submit: false), temporary_assigns: [form: nil]} else {:ok, socket |> put_flash(:error, "Magic link is invalid or it has expired.") |> push_navigate(to: ~p"<%= schema.route_prefix %>/log-in")} end end @impl true def handle_event("submit", %{"<%= schema.singular %>" => params}, socket) do {:noreply, assign(socket, form: to_form(params, as: "<%= schema.singular %>"), trigger_submit: true)} end end ================================================ FILE: priv/templates/phx.gen.auth/confirmation_live_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.ConfirmationTest do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> import Phoenix.LiveViewTest import <%= inspect context.module %>Fixtures alias <%= inspect context.module %> setup do %{unconfirmed_<%= schema.singular %>: unconfirmed_<%= schema.singular %>_fixture(), confirmed_<%= schema.singular %>: <%= schema.singular %>_fixture()} end describe "Confirm <%= schema.singular %>" do test "renders confirmation page for unconfirmed <%= schema.singular %>", %{conn: conn, unconfirmed_<%= schema.singular %>: <%= schema.singular %>} do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") assert html =~ "Confirm and stay logged in" end test "renders login page for confirmed <%= schema.singular %>", %{conn: conn, confirmed_<%= schema.singular %>: <%= schema.singular %>} do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") refute html =~ "Confirm my account" assert html =~ "Keep me logged in on this device" end test "renders login page for already logged in <%= schema.singular %>", %{conn: conn, confirmed_<%= schema.singular %>: <%= schema.singular %>} do conn = log_in_<%= schema.singular %>(conn, <%= schema.singular %>) token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") refute html =~ "Confirm my account" assert html =~ "Log in" end test "confirms the given token once", %{conn: conn, unconfirmed_<%= schema.singular %>: <%= schema.singular %>} do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") form = form(lv, "#confirmation_form", %{"<%= schema.singular %>" => %{"token" => token}}) render_submit(form) conn = follow_trigger_action(form, conn) assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "<%= inspect schema.alias %> confirmed successfully" assert <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= schema.singular %>.id).confirmed_at # we are logged in now assert get_session(conn, :<%= schema.singular %>_token) assert redirected_to(conn) == ~p"/" # log out, new conn conn = build_conn() {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ "Magic link is invalid or it has expired" end test "logs confirmed <%= schema.singular %> in without changing confirmed_at", %{ conn: conn, confirmed_<%= schema.singular %>: <%= schema.singular %> } do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") form = form(lv, "#login_form", %{"<%= schema.singular %>" => %{"token" => token}}) render_submit(form) conn = follow_trigger_action(form, conn) assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Welcome back!" assert <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= schema.singular %>.id).confirmed_at == <%= schema.singular %>.confirmed_at # log out, new conn conn = build_conn() {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ "Magic link is invalid or it has expired" end test "raises error for invalid token", %{conn: conn} do {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in/invalid-token") |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ "Magic link is invalid or it has expired" end end end ================================================ FILE: priv/templates/phx.gen.auth/conn_case.exs.eex ================================================ @doc """ Setup helper that registers and logs in <%= schema.plural %>. setup :register_and_log_in_<%= schema.singular %> It stores an updated connection and a registered <%= schema.singular %> in the test context. """ def register_and_log_in_<%= schema.singular %>(%{conn: conn} = context) do <%= schema.singular %> = <%= inspect context.module %>Fixtures.<%= schema.singular %>_fixture() scope = <%= inspect scope_config.scope.module %>.for_<%= schema.singular %>(<%= schema.singular %>) opts = context |> Map.take([:token_authenticated_at]) |> Enum.into([]) %{conn: log_in_<%= schema.singular %>(conn, <%= schema.singular %>, opts), <%= schema.singular %>: <%= schema.singular %>, scope: scope} end @doc """ Logs the given `<%= schema.singular %>` into the `conn`. It returns an updated `conn`. """ def log_in_<%= schema.singular %>(conn, <%= schema.singular %>, opts \\ []) do token = <%= inspect context.module %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) maybe_set_token_authenticated_at(token, opts[:token_authenticated_at]) conn |> Phoenix.ConnTest.init_test_session(%{}) |> Plug.Conn.put_session(:<%= schema.singular %>_token, token) end defp maybe_set_token_authenticated_at(_token, nil), do: nil defp maybe_set_token_authenticated_at(token, authenticated_at) do <%= inspect context.module %>Fixtures.override_token_authenticated_at(token, authenticated_at) end ================================================ FILE: priv/templates/phx.gen.auth/context_fixtures_functions.ex.eex ================================================ import Ecto.Query alias <%= inspect context.module %> alias <%= inspect scope_config.scope.module %> def unique_<%= schema.singular %>_email, do: "<%= schema.singular %>#{System.unique_integer()}@example.com" def valid_<%= schema.singular %>_password, do: "hello world!" def valid_<%= schema.singular %>_attributes(attrs \\ %{}) do Enum.into(attrs, %{ email: unique_<%= schema.singular %>_email() }) end def unconfirmed_<%= schema.singular %>_fixture(attrs \\ %{}) do {:ok, <%= schema.singular %>} = attrs |> valid_<%= schema.singular %>_attributes() |> <%= inspect context.alias %>.register_<%= schema.singular %>() <%= schema.singular %> end def <%= schema.singular %>_fixture(attrs \\ %{}) do <%= schema.singular %> = unconfirmed_<%= schema.singular %>_fixture(attrs) token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) {:ok, {<%= schema.singular %>, _expired_tokens}} = <%= inspect context.alias %>.login_<%= schema.singular %>_by_magic_link(token) <%= schema.singular %> end def <%= schema.singular %>_scope_fixture do <%= schema.singular %> = <%= schema.singular %>_fixture() <%= schema.singular %>_scope_fixture(<%= schema.singular %>) end def <%= schema.singular %>_scope_fixture(<%= schema.singular %>) do <%= inspect scope_config.scope.alias %>.for_<%= schema.singular %>(<%= schema.singular %>) end def set_password(<%= schema.singular %>) do {:ok, {<%= schema.singular %>, _expired_tokens}} = <%= inspect context.alias %>.update_<%= schema.singular %>_password(<%= schema.singular %>, %{password: valid_<%= schema.singular %>_password()}) <%= schema.singular %> end def extract_<%= schema.singular %>_token(fun) do {:ok, captured_email} = fun.(&"[TOKEN]#{&1}[TOKEN]") [_, token | _] = String.split(captured_email.text_body, "[TOKEN]") token end def override_token_authenticated_at(token, authenticated_at) when is_binary(token) do <%= inspect schema.repo %>.update_all( from(t in <%= inspect context.alias %>.<%= inspect schema.alias %>Token, where: t.token == ^token ), set: [authenticated_at: authenticated_at] ) end def generate_<%= schema.singular %>_magic_link_token(<%= schema.singular %>) do {encoded_token, <%= schema.singular %>_token} = <%= inspect context.alias %>.<%= inspect schema.alias %>Token.build_email_token(<%= schema.singular %>, "login") <%= inspect schema.repo %>.insert!(<%= schema.singular %>_token) {encoded_token, <%= schema.singular %>_token.token} end def offset_<%= schema.singular %>_token(token, amount_to_add, unit) do dt = <%= inspect datetime_module %>.add(<%= datetime_now %>, amount_to_add, unit) <%= inspect schema.repo %>.update_all( from(ut in <%= inspect context.alias %>.<%= inspect schema.alias %>Token, where: ut.token == ^token), set: [inserted_at: dt, authenticated_at: dt] ) end ================================================ FILE: priv/templates/phx.gen.auth/context_functions.ex.eex ================================================ alias <%= inspect context.module %>.{<%= inspect schema.alias %>, <%= inspect schema.alias %>Token, <%= inspect schema.alias %>Notifier} ## Database getters @doc """ Gets a <%= schema.singular %> by email. ## Examples iex> get_<%= schema.singular %>_by_email("foo@example.com") %<%= inspect schema.alias %>{} iex> get_<%= schema.singular %>_by_email("unknown@example.com") nil """ def get_<%= schema.singular %>_by_email(email) when is_binary(email) do Repo.get_by(<%= inspect schema.alias %>, email: email) end @doc """ Gets a <%= schema.singular %> by email and password. ## Examples iex> get_<%= schema.singular %>_by_email_and_password("foo@example.com", "correct_password") %<%= inspect schema.alias %>{} iex> get_<%= schema.singular %>_by_email_and_password("foo@example.com", "invalid_password") nil """ def get_<%= schema.singular %>_by_email_and_password(email, password) when is_binary(email) and is_binary(password) do <%= schema.singular %> = Repo.get_by(<%= inspect schema.alias %>, email: email) if <%= inspect schema.alias %>.valid_password?(<%= schema.singular %>, password), do: <%= schema.singular %> end @doc """ Gets a single <%= schema.singular %>. Raises `Ecto.NoResultsError` if the <%= inspect schema.alias %> does not exist. ## Examples iex> get_<%= schema.singular %>!(123) %<%= inspect schema.alias %>{} iex> get_<%= schema.singular %>!(456) ** (Ecto.NoResultsError) """ def get_<%= schema.singular %>!(id), do: Repo.get!(<%= inspect schema.alias %>, id) ## <%= schema.human_singular %> registration @doc """ Registers a <%= schema.singular %>. ## Examples iex> register_<%= schema.singular %>(%{field: value}) {:ok, %<%= inspect schema.alias %>{}} iex> register_<%= schema.singular %>(%{field: bad_value}) {:error, %Ecto.Changeset{}} """ def register_<%= schema.singular %>(attrs) do %<%= inspect schema.alias %>{} |> <%= inspect schema.alias %>.email_changeset(attrs) |> Repo.insert() end ## Settings @doc """ Checks whether the <%= schema.singular %> is in sudo mode. The <%= schema.singular %> is in sudo mode when the last authentication was done no further than 20 minutes ago. The limit can be given as second argument in minutes. """ def sudo_mode?(<%= schema.singular %>, minutes \\ -20) def sudo_mode?(%<%= inspect schema.alias %>{authenticated_at: ts}, minutes) when is_struct(ts, <%= inspect datetime_module %>) do <%= inspect datetime_module %>.after?(ts, <%= inspect datetime_module %>.utc_now() |> <%= inspect datetime_module %>.add(minutes, :minute)) end def sudo_mode?(_<%= schema.singular %>, _minutes), do: false @doc """ Returns an `%Ecto.Changeset{}` for changing the <%= schema.singular %> email. See `<%= inspect context.module %>.<%= inspect schema.alias %>.email_changeset/3` for a list of supported options. ## Examples iex> change_<%= schema.singular %>_email(<%= schema.singular %>) %Ecto.Changeset{data: %<%= inspect schema.alias %>{}} """ def change_<%= schema.singular %>_email(<%= schema.singular %>, attrs \\ %{}, opts \\ []) do <%= inspect schema.alias %>.email_changeset(<%= schema.singular %>, attrs, opts) end @doc """ Updates the <%= schema.singular %> email using the given token. If the token matches, the <%= schema.singular %> email is updated and the token is deleted. """ def update_<%= schema.singular %>_email(<%= schema.singular %>, token) do context = "change:#{<%= schema.singular %>.email}" Repo.transact(fn -> with {:ok, query} <- <%= inspect schema.alias %>Token.verify_change_email_token_query(token, context), %<%= inspect schema.alias %>Token{sent_to: email} <- Repo.one(query), {:ok, <%= schema.singular %>} <- Repo.update(<%= inspect schema.alias %>.email_changeset(<%= schema.singular %>, %{email: email})), {_count, _result} <- Repo.delete_all(from(<%= inspect schema.alias %>Token, where: [<%= schema.singular %>_id: ^<%= schema.singular %>.id, context: ^context])) do {:ok, <%= schema.singular %>} else _ -> {:error, :transaction_aborted} end end) end @doc """ Returns an `%Ecto.Changeset{}` for changing the <%= schema.singular %> password. See `<%= inspect context.module %>.<%= inspect schema.alias %>.password_changeset/3` for a list of supported options. ## Examples iex> change_<%= schema.singular %>_password(<%= schema.singular %>) %Ecto.Changeset{data: %<%= inspect schema.alias %>{}} """ def change_<%= schema.singular %>_password(<%= schema.singular %>, attrs \\ %{}, opts \\ []) do <%= inspect schema.alias %>.password_changeset(<%= schema.singular %>, attrs, opts) end @doc """ Updates the <%= schema.singular %> password. Returns a tuple with the updated <%= schema.singular %>, as well as a list of expired tokens. ## Examples iex> update_<%= schema.singular %>_password(<%= schema.singular %>, %{password: ...}) {:ok, {%<%= inspect schema.alias %>{}, [...]}} iex> update_<%= schema.singular %>_password(<%= schema.singular %>, %{password: "too short"}) {:error, %Ecto.Changeset{}} """ def update_<%= schema.singular %>_password(<%= schema.singular %>, attrs) do <%= schema.singular %> |> <%= inspect schema.alias %>.password_changeset(attrs) |> update_<%= schema.singular %>_and_delete_all_tokens() end ## Session @doc """ Generates a session token. """ def generate_<%= schema.singular %>_session_token(<%= schema.singular %>) do {token, <%= schema.singular %>_token} = <%= inspect schema.alias %>Token.build_session_token(<%= schema.singular %>) Repo.insert!(<%= schema.singular %>_token) token end @doc """ Gets the <%= schema.singular %> with the given signed token. If the token is valid `{<%= schema.singular %>, token_inserted_at}` is returned, otherwise `nil` is returned. """ def get_<%= schema.singular %>_by_session_token(token) do {:ok, query} = <%= inspect schema.alias %>Token.verify_session_token_query(token) Repo.one(query) end @doc """ Gets the <%= schema.singular %> with the given magic link token. """ def get_<%= schema.singular %>_by_magic_link_token(token) do with {:ok, query} <- <%= inspect schema.alias %>Token.verify_magic_link_token_query(token), {<%= schema.singular %>, _token} <- Repo.one(query) do <%= schema.singular %> else _ -> nil end end @doc """ Logs the <%= schema.singular %> in by magic link. There are three cases to consider: 1. The <%= schema.singular %> has already confirmed their email. They are logged in and the magic link is expired. 2. The <%= schema.singular %> has not confirmed their email and no password is set. In this case, the <%= schema.singular %> gets confirmed, logged in, and all tokens - including session ones - are expired. In theory, no other tokens exist but we delete all of them for best security practices. 3. The <%= schema.singular %> has not confirmed their email but a password is set. This cannot happen in the default implementation but may be the source of security pitfalls. See the "Mixing magic link and password registration" section of `mix help phx.gen.auth`. """ def login_<%= schema.singular %>_by_magic_link(token) do {:ok, query} = <%= inspect schema.alias %>Token.verify_magic_link_token_query(token) case Repo.one(query) do # Prevent session fixation attacks by disallowing magic links for unconfirmed users with password {%<%= inspect schema.alias %>{confirmed_at: nil, hashed_password: hash}, _token} when not is_nil(hash) -> raise """ magic link log in is not allowed for unconfirmed users with a password set! This cannot happen with the default implementation, which indicates that you might have adapted the code to a different use case. Please make sure to read the "Mixing magic link and password registration" section of `mix help phx.gen.auth`. """ {%<%= inspect schema.alias %>{confirmed_at: nil} = <%= schema.singular %>, _token} -> <%= schema.singular %> |> <%= inspect schema.alias %>.confirm_changeset() |> update_<%= schema.singular %>_and_delete_all_tokens() {<%= schema.singular %>, token} -> Repo.delete!(token) {:ok, {<%= schema.singular %>, []}} nil -> {:error, :not_found} end end @doc ~S""" Delivers the update email instructions to the given <%= schema.singular %>. ## Examples iex> deliver_<%= schema.singular %>_update_email_instructions(<%= schema.singular %>, current_email, &url(~p"<%= schema.route_prefix %>/settings/confirm-email/#{&1}")) {:ok, %{to: ..., body: ...}} """ def deliver_<%= schema.singular %>_update_email_instructions(%<%= inspect schema.alias %>{} = <%= schema.singular %>, current_email, update_email_url_fun) when is_function(update_email_url_fun, 1) do {encoded_token, <%= schema.singular %>_token} = <%= inspect schema.alias %>Token.build_email_token(<%= schema.singular %>, "change:#{current_email}") Repo.insert!(<%= schema.singular %>_token) <%= inspect schema.alias %>Notifier.deliver_update_email_instructions(<%= schema.singular %>, update_email_url_fun.(encoded_token)) end @doc """ Delivers the magic link login instructions to the given <%= schema.singular %>. """ def deliver_login_instructions(%<%= inspect schema.alias %>{} = <%= schema.singular %>, magic_link_url_fun) when is_function(magic_link_url_fun, 1) do {encoded_token, <%= schema.singular %>_token} = <%= inspect schema.alias %>Token.build_email_token(<%= schema.singular %>, "login") Repo.insert!(<%= schema.singular %>_token) <%= inspect schema.alias %>Notifier.deliver_login_instructions(<%= schema.singular %>, magic_link_url_fun.(encoded_token)) end @doc """ Deletes the signed token with the given context. """ def delete_<%= schema.singular %>_session_token(token) do Repo.delete_all(from(<%= inspect schema.alias %>Token, where: [token: ^token, context: "session"])) :ok end ## Token helper defp update_<%= schema.singular %>_and_delete_all_tokens(changeset) do Repo.transact(fn -> with {:ok, <%= schema.singular %>} <- Repo.update(changeset) do tokens_to_expire = Repo.all_by(<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id) Repo.delete_all(from(t in <%= inspect schema.alias %>Token, where: t.id in ^Enum.map(tokens_to_expire, & &1.id))) {:ok, {<%= schema.singular %>, tokens_to_expire}} end end) end ================================================ FILE: priv/templates/phx.gen.auth/login_live.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.Login do use <%= inspect context.web_module %>, :live_view alias <%= inspect context.module %> @impl true def render(assigns) do ~H""" ={@<%= scope_config.scope.assign_key %>}>
<.header>

Log in

<:subtitle> <%%= if @<%= scope_config.scope.assign_key %> do %> You need to reauthenticate to perform sensitive actions on your account. <%% else %> Don't have an account? <.link navigate={~p"<%= schema.route_prefix %>/register"} class="font-semibold text-brand hover:underline" phx-no-format >Sign up for an account now. <%% end %>
<.icon name="hero-information-circle" class="size-6 shrink-0" />

You are running the local mail adapter.

To see sent emails, visit <.link href="/dev/mailbox" class="underline">the mailbox page.

<.form :let={f} for={@form} id="login_form_magic" action={~p"<%= schema.route_prefix %>/log-in"} phx-submit="submit_magic" > <.input readonly={!!@<%= scope_config.scope.assign_key %>} field={f[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required phx-mounted={JS.focus()} /> <.button class="btn btn-primary w-full"> Log in with email
or
<.form :let={f} for={@form} id="login_form_password" action={~p"<%= schema.route_prefix %>/log-in"} phx-submit="submit_password" phx-trigger-action={@trigger_submit} > <.input readonly={!!@<%= scope_config.scope.assign_key %>} field={f[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required /> <.input field={@form[:password]} type="password" label="Password" autocomplete="current-password" spellcheck="false" /> <.button class="btn btn-primary w-full" name={@form[:remember_me].name} value="true"> Log in and stay logged in <.button class="btn btn-primary btn-soft w-full mt-2"> Log in only this time
""" end @impl true def mount(_params, _session, socket) do email = Phoenix.Flash.get(socket.assigns.flash, :email) || get_in(socket.assigns, [:<%= scope_config.scope.assign_key %>, Access.key(:<%= schema.singular %>), Access.key(:email)]) form = to_form(%{"email" => email}, as: "<%= schema.singular %>") {:ok, assign(socket, form: form, trigger_submit: false)} end @impl true def handle_event("submit_password", _params, socket) do {:noreply, assign(socket, :trigger_submit, true)} end def handle_event("submit_magic", %{"<%= schema.singular %>" => %{"email" => email}}, socket) do if <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(email) do <%= inspect context.alias %>.deliver_login_instructions( <%= schema.singular %>, &url(~p"<%= schema.route_prefix %>/log-in/#{&1}") ) end info = "If your email is in our system, you will receive instructions for logging in shortly." {:noreply, socket |> put_flash(:info, info) |> push_navigate(to: ~p"<%= schema.route_prefix %>/log-in")} end defp local_mail_adapter? do Application.get_env(:<%= Mix.Phoenix.otp_app() %>, <%= inspect context.base_module %>.Mailer)[:adapter] == Swoosh.Adapters.Local end end ================================================ FILE: priv/templates/phx.gen.auth/login_live_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.LoginTest do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> import Phoenix.LiveViewTest import <%= inspect context.module %>Fixtures describe "login page" do test "renders login page", %{conn: conn} do {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ "Log in" assert html =~ "Register" assert html =~ "Log in with email" end end describe "<%= schema.singular %> login - magic link" do test "sends magic link email when <%= schema.singular %> exists", %{conn: conn} do <%= schema.singular %> = <%= schema.singular %>_fixture() {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/log-in") {:ok, _lv, html} = form(lv, "#login_form_magic", <%= schema.singular %>: %{email: <%= schema.singular %>.email}) |> render_submit() |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ "If your email is in our system" assert <%= inspect schema.repo %>.get_by!(<%= inspect context.module %>.<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id).context == "login" end test "does not disclose if <%= schema.singular %> is registered", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/log-in") {:ok, _lv, html} = form(lv, "#login_form_magic", <%= schema.singular %>: %{email: "idonotexist@example.com"}) |> render_submit() |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ "If your email is in our system" end end describe "<%= schema.singular %> login - password" do test "redirects if <%= schema.singular %> logs in with valid credentials", %{conn: conn} do <%= schema.singular %> = <%= schema.singular %>_fixture() |> set_password() {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/log-in") form = form(lv, "#login_form_password", <%= schema.singular %>: %{email: <%= schema.singular %>.email, password: valid_<%= schema.singular %>_password(), remember_me: true} ) conn = submit_form(form, conn) assert redirected_to(conn) == ~p"/" end test "redirects to login page with a flash error if credentials are invalid", %{ conn: conn } do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/log-in") form = form(lv, "#login_form_password", <%= schema.singular %>: %{email: "test@email.com", password: "123456"}) render_submit(form, %{user: %{remember_me: true}}) conn = follow_trigger_action(form, conn) assert Phoenix.Flash.get(conn.assigns.flash, :error) == "Invalid email or password" assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" end end describe "login navigation" do test "redirects to registration page when the Register button is clicked", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/log-in") {:ok, _login_live, login_html} = lv |> element("main a", "Sign up") |> render_click() |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/register") assert login_html =~ "Register" end end describe "re-authentication (sudo mode)" do setup %{conn: conn} do <%= schema.singular %> = <%= schema.singular %>_fixture() %{<%= schema.singular %>: <%= schema.singular %>, conn: log_in_<%= schema.singular %>(conn, <%= schema.singular %>)} end test "shows login page with email filled in", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ "You need to reauthenticate" refute html =~ "Register" assert html =~ "Log in with email" assert html =~ ~s(.Migrations.Create<%= Macro.camelize(schema.table) %>AuthTables do use <%= inspect schema.migration_module %> def change do<%= if Enum.any?(migration.extensions) do %><%= for extension <- migration.extensions do %> <%= extension %><% end %> <% end %> create table(:<%= schema.table %><%= if schema.binary_id do %>, primary_key: false<% end %>) do <%= if schema.binary_id do %> add :id, :binary_id, primary_key: true <% end %> <%= migration.column_definitions[:email] %> add :hashed_password, :string add :confirmed_at, <%= inspect schema.timestamp_type %> timestamps(<%= if schema.timestamp_type != :naive_datetime, do: "type: #{inspect schema.timestamp_type}" %>) end create unique_index(:<%= schema.table %>, [:email]) create table(:<%= schema.table %>_tokens<%= if schema.binary_id do %>, primary_key: false<% end %>) do <%= if schema.binary_id do %> add :id, :binary_id, primary_key: true <% end %> add :<%= schema.singular %>_id, references(:<%= schema.table %>, <%= if schema.binary_id do %>type: :binary_id, <% end %>on_delete: :delete_all), null: false <%= migration.column_definitions[:token] %> add :context, :string, null: false add :sent_to, :string add :authenticated_at, <%= inspect schema.timestamp_type %> timestamps(<%= if schema.timestamp_type != :naive_datetime, do: "type: #{inspect schema.timestamp_type}, " %>updated_at: false) end create index(:<%= schema.table %>_tokens, [:<%= schema.singular %>_id]) create unique_index(:<%= schema.table %>_tokens, [:context, :token]) end end ================================================ FILE: priv/templates/phx.gen.auth/notifier.ex.eex ================================================ defmodule <%= inspect context.module %>.<%= inspect schema.alias %>Notifier do import Swoosh.Email alias <%= inspect context.base_module %>.Mailer alias <%= inspect context.module %>.<%= inspect schema.alias %> # Delivers the email using the application mailer. defp deliver(recipient, subject, body) do email = new() |> to(recipient) |> from({"<%= inspect context.base_module %>", "contact@example.com"}) |> subject(subject) |> text_body(body) with {:ok, _metadata} <- Mailer.deliver(email) do {:ok, email} end end @doc """ Deliver instructions to update a <%= schema.singular %> email. """ def deliver_update_email_instructions(<%= schema.singular %>, url) do deliver(<%= schema.singular %>.email, "Update email instructions", """ ============================== Hi #{<%= schema.singular %>.email}, You can change your email by visiting the URL below: #{url} If you didn't request this change, please ignore this. ============================== """) end @doc """ Deliver instructions to log in with a magic link. """ def deliver_login_instructions(<%= schema.singular %>, url) do case <%= schema.singular %> do %<%= inspect schema.alias %>{confirmed_at: nil} -> deliver_confirmation_instructions(<%= schema.singular %>, url) _ -> deliver_magic_link_instructions(<%= schema.singular %>, url) end end defp deliver_magic_link_instructions(<%= schema.singular %>, url) do deliver(<%= schema.singular %>.email, "Log in instructions", """ ============================== Hi #{<%= schema.singular %>.email}, You can log into your account by visiting the URL below: #{url} If you didn't request this email, please ignore this. ============================== """) end defp deliver_confirmation_instructions(<%= schema.singular %>, url) do deliver(<%= schema.singular %>.email, "Confirmation instructions", """ ============================== Hi #{<%= schema.singular %>.email}, You can confirm your account by visiting the URL below: #{url} If you didn't create an account with us, please ignore this. ============================== """) end end ================================================ FILE: priv/templates/phx.gen.auth/registration_controller.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>RegistrationController do use <%= inspect context.web_module %>, :controller alias <%= inspect context.module %> alias <%= inspect schema.module %> def new(conn, _params) do changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_email(%<%= inspect schema.alias %>{}) render(conn, :new, changeset: changeset) end def create(conn, %{"<%= schema.singular %>" => <%= schema.singular %>_params}) do case <%= inspect context.alias %>.register_<%= schema.singular %>(<%= schema.singular %>_params) do {:ok, <%= schema.singular %>} -> {:ok, _} = <%= inspect context.alias %>.deliver_login_instructions( <%= schema.singular %>, &url(~p"<%= schema.route_prefix %>/log-in/#{&1}") ) conn |> put_flash( :info, "An email was sent to #{<%= schema.singular %>.email}, please access it to confirm your account." ) |> redirect(to: ~p"<%= schema.route_prefix %>/log-in") {:error, %Ecto.Changeset{} = changeset} -> render(conn, :new, changeset: changeset) end end end ================================================ FILE: priv/templates/phx.gen.auth/registration_controller_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>RegistrationControllerTest do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> import <%= inspect context.module %>Fixtures describe "GET <%= schema.route_prefix %>/register" do test "renders registration page", %{conn: conn} do conn = get(conn, ~p"<%= schema.route_prefix %>/register") response = html_response(conn, 200) assert response =~ "Register" assert response =~ ~p"<%= schema.route_prefix %>/log-in" assert response =~ ~p"<%= schema.route_prefix %>/register" end test "redirects if already logged in", %{conn: conn} do conn = conn |> log_in_<%= schema.singular %>(<%= schema.singular %>_fixture()) |> get(~p"<%= schema.route_prefix %>/register") assert redirected_to(conn) == ~p"/" end end describe "POST <%= schema.route_prefix %>/register" do @tag :capture_log test "creates account but does not log in", %{conn: conn} do email = unique_<%= schema.singular %>_email() conn = post(conn, ~p"<%= schema.route_prefix %>/register", %{ "<%= schema.singular %>" => valid_<%= schema.singular %>_attributes(email: email) }) refute get_session(conn, :<%= schema.singular %>_token) assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" assert conn.assigns.flash["info"] =~ ~r/An email was sent to .*, please access it to confirm your account/ end test "render errors for invalid data", %{conn: conn} do conn = post(conn, ~p"<%= schema.route_prefix %>/register", %{ "<%= schema.singular %>" => %{"email" => "with spaces"} }) response = html_response(conn, 200) assert response =~ "Register" assert response =~ "must have the @ sign and no spaces" end end end ================================================ FILE: priv/templates/phx.gen.auth/registration_html.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>RegistrationHTML do use <%= inspect context.web_module %>, :html embed_templates "<%= schema.singular %>_registration_html/*" end ================================================ FILE: priv/templates/phx.gen.auth/registration_live.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.Registration do use <%= inspect context.web_module %>, :live_view alias <%= inspect context.module %> alias <%= inspect schema.module %> @impl true def render(assigns) do ~H""" ={@<%= scope_config.scope.assign_key %>}>
<.header> Register for an account <:subtitle> Already registered? <.link navigate={~p"<%= schema.route_prefix %>/log-in"} class="font-semibold text-brand hover:underline"> Log in to your account now.
<.form for={@form} id="registration_form" phx-submit="save" phx-change="validate"> <.input field={@form[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required phx-mounted={JS.focus()} /> <.button phx-disable-with="Creating account..." class="btn btn-primary w-full"> Create an account
""" end @impl true def mount(_params, _session, %{assigns: %{<%= scope_config.scope.assign_key %>: %{<%= schema.singular %>: <%= schema.singular %>}}} = socket) when not is_nil(<%= schema.singular %>) do {:ok, redirect(socket, to: <%= inspect auth_module %>.signed_in_path(socket))} end def mount(_params, _session, socket) do changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_email(%<%= inspect schema.alias %>{}, %{}, validate_unique: false) {:ok, assign_form(socket, changeset), temporary_assigns: [form: nil]} end @impl true def handle_event("save", %{"<%= schema.singular %>" => <%= schema.singular %>_params}, socket) do case <%= inspect context.alias %>.register_<%= schema.singular %>(<%= schema.singular %>_params) do {:ok, <%= schema.singular %>} -> {:ok, _} = <%= inspect context.alias %>.deliver_login_instructions( <%= schema.singular %>, &url(~p"<%= schema.route_prefix %>/log-in/#{&1}") ) {:noreply, socket |> put_flash( :info, "An email was sent to #{<%= schema.singular %>.email}, please access it to confirm your account." ) |> push_navigate(to: ~p"<%= schema.route_prefix %>/log-in")} {:error, %Ecto.Changeset{} = changeset} -> {:noreply, assign_form(socket, changeset)} end end def handle_event("validate", %{"<%= schema.singular %>" => <%= schema.singular %>_params}, socket) do changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_email(%<%= inspect schema.alias %>{}, <%= schema.singular %>_params, validate_unique: false) {:noreply, assign_form(socket, Map.put(changeset, :action, :validate))} end defp assign_form(socket, %Ecto.Changeset{} = changeset) do form = to_form(changeset, as: "<%= schema.singular %>") assign(socket, form: form) end end ================================================ FILE: priv/templates/phx.gen.auth/registration_live_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.RegistrationTest do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> import Phoenix.LiveViewTest import <%= inspect context.module %>Fixtures describe "Registration page" do test "renders registration page", %{conn: conn} do {:ok, _lv, html} = live(conn, ~p"<%= schema.route_prefix %>/register") assert html =~ "Register" assert html =~ "Log in" end test "redirects if already logged in", %{conn: conn} do result = conn |> log_in_<%= schema.singular %>(<%= schema.singular %>_fixture()) |> live(~p"<%= schema.route_prefix %>/register") |> follow_redirect(conn, ~p"/") assert {:ok, _conn} = result end test "renders errors for invalid data", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/register") result = lv |> element("#registration_form") |> render_change(<%= schema.singular %>: %{"email" => "with spaces"}) assert result =~ "Register" assert result =~ "must have the @ sign and no spaces" end end describe "register <%= schema.singular %>" do test "creates account but does not log in", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/register") email = unique_<%= schema.singular %>_email() form = form(lv, "#registration_form", <%= schema.singular %>: valid_<%= schema.singular %>_attributes(email: email)) {:ok, _lv, html} = render_submit(form) |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert html =~ ~r/An email was sent to .*, please access it to confirm your account/ end test "renders errors for duplicated email", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/register") <%= schema.singular %> = <%= schema.singular %>_fixture(%{email: "test@email.com"}) result = lv |> form("#registration_form", <%= schema.singular %>: %{"email" => <%= schema.singular %>.email} ) |> render_submit() assert result =~ "has already been taken" end end describe "registration navigation" do test "redirects to login page when the Log in button is clicked", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/register") {:ok, _login_live, login_html} = lv |> element("main a", "Log in") |> render_click() |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert login_html =~ "Log in" end end end ================================================ FILE: priv/templates/phx.gen.auth/registration_new.html.heex.eex ================================================ ={@<%= scope_config.scope.assign_key %>}>
<.header> Register for an account <:subtitle> Already registered? <.link navigate={~p"<%= schema.route_prefix %>/log-in"} class="font-semibold text-brand hover:underline"> Log in to your account now.
<.form :let={f} for={@changeset} action={~p"<%= schema.route_prefix %>/register"}> <.input field={f[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required phx-mounted={JS.focus()} /> <.button phx-disable-with="Creating account..." class="btn btn-primary w-full"> Create an account
================================================ FILE: priv/templates/phx.gen.auth/routes.ex.eex ================================================ ## Authentication routes <%= if not live? do %>scope <%= router_scope %> do pipe_through [:browser, :redirect_if_<%= schema.singular %>_is_authenticated] get "/<%= schema.plural %>/register", <%= inspect schema.alias %>RegistrationController, :new post "/<%= schema.plural %>/register", <%= inspect schema.alias %>RegistrationController, :create end <% end %>scope <%= router_scope %> do pipe_through [:browser, :require_authenticated_<%= schema.singular %>]<%= if live? do %> live_session :require_authenticated_<%= schema.singular %>, on_mount: [{<%= inspect auth_module %>, :require_authenticated}] do live "/<%= schema.plural %>/settings", <%= inspect schema.alias %>Live.Settings, :edit live "/<%= schema.plural %>/settings/confirm-email/:token", <%= inspect schema.alias %>Live.Settings, :confirm_email end post "/<%= schema.plural %>/update-password", <%= inspect schema.alias %>SessionController, :update_password<% else %> get "/<%= schema.plural %>/settings", <%= inspect schema.alias %>SettingsController, :edit put "/<%= schema.plural %>/settings", <%= inspect schema.alias %>SettingsController, :update get "/<%= schema.plural %>/settings/confirm-email/:token", <%= inspect schema.alias %>SettingsController, :confirm_email<% end %> end scope <%= router_scope %> do pipe_through [:browser] <%= if live? do %>live_session :current_<%= schema.singular %>, on_mount: [{<%= inspect auth_module %>, :mount_<%= scope_config.scope.assign_key %>}] do live "/<%= schema.plural %>/register", <%= inspect schema.alias %>Live.Registration, :new live "/<%= schema.plural %>/log-in", <%= inspect schema.alias %>Live.Login, :new live "/<%= schema.plural %>/log-in/:token", <%= inspect schema.alias %>Live.Confirmation, :new end post "/<%= schema.plural %>/log-in", <%= inspect schema.alias %>SessionController, :create delete "/<%= schema.plural %>/log-out", <%= inspect schema.alias %>SessionController, :delete<% else %>get "/<%= schema.plural %>/log-in", <%= inspect schema.alias %>SessionController, :new get "/<%= schema.plural %>/log-in/:token", <%= inspect schema.alias %>SessionController, :confirm post "/<%= schema.plural %>/log-in", <%= inspect schema.alias %>SessionController, :create delete "/<%= schema.plural %>/log-out", <%= inspect schema.alias %>SessionController, :delete<% end %> end ================================================ FILE: priv/templates/phx.gen.auth/schema.ex.eex ================================================ defmodule <%= inspect schema.module %> do use Ecto.Schema import Ecto.Changeset <%= if schema.binary_id do %> @primary_key {:id, :binary_id, autogenerate: true} @foreign_key_type :binary_id<% end %> schema <%= inspect schema.table %> do field :email, :string field :password, :string, virtual: true, redact: true field :hashed_password, :string, redact: true field :confirmed_at, <%= inspect schema.timestamp_type %> field :authenticated_at, <%= inspect schema.timestamp_type %>, virtual: true timestamps(<%= if schema.timestamp_type != :naive_datetime, do: "type: #{inspect schema.timestamp_type}" %>) end @doc """ A <%= schema.singular %> changeset for registering or changing the email. It requires the email to change otherwise an error is added. ## Options * `:validate_unique` - Set to false if you don't want to validate the uniqueness of the email, useful when displaying live validations. Defaults to `true`. """ def email_changeset(<%= schema.singular %>, attrs, opts \\ []) do <%= schema.singular %> |> cast(attrs, [:email]) |> validate_email(opts) end defp validate_email(changeset, opts) do changeset = changeset |> validate_required([:email]) |> validate_format(:email, ~r/^[^@,;\s]+@[^@,;\s]+$/, message: "must have the @ sign and no spaces" ) |> validate_length(:email, max: 160) if Keyword.get(opts, :validate_unique, true) do changeset |> unsafe_validate_unique(:email, <%= inspect schema.repo %>) |> unique_constraint(:email) |> validate_email_changed() else changeset end end defp validate_email_changed(changeset) do if get_field(changeset, :email) && get_change(changeset, :email) == nil do add_error(changeset, :email, "did not change") else changeset end end @doc """ A <%= schema.singular %> changeset for changing the password. It is important to validate the length of the password, as long passwords may be very expensive to hash for certain algorithms. ## Options * `:hash_password` - Hashes the password so it can be stored securely in the database and ensures the password field is cleared to prevent leaks in the logs. If password hashing is not needed and clearing the password field is not desired (like when using this changeset for validations on a LiveView form), this option can be set to `false`. Defaults to `true`. """ def password_changeset(<%= schema.singular %>, attrs, opts \\ []) do <%= schema.singular %> |> cast(attrs, [:password]) |> validate_confirmation(:password, message: "does not match password") |> validate_password(opts) end defp validate_password(changeset, opts) do changeset |> validate_required([:password]) |> validate_length(:password, min: 12, max: 72) # Examples of additional password validation: # |> validate_format(:password, ~r/[a-z]/, message: "at least one lower case character") # |> validate_format(:password, ~r/[A-Z]/, message: "at least one upper case character") # |> validate_format(:password, ~r/[!?@#$%^&*_0-9]/, message: "at least one digit or punctuation character") |> maybe_hash_password(opts) end defp maybe_hash_password(changeset, opts) do hash_password? = Keyword.get(opts, :hash_password, true) password = get_change(changeset, :password) if hash_password? && password && changeset.valid? do changeset<%= if hashing_library.name == :bcrypt do %> # If using Bcrypt, then further validate it is at most 72 bytes long |> validate_length(:password, max: 72, count: :bytes)<% end %> # Hashing could be done with `Ecto.Changeset.prepare_changes/2`, but that # would keep the database transaction open longer and hurt performance. |> put_change(:hashed_password, <%= inspect hashing_library.module %>.hash_pwd_salt(password)) |> delete_change(:password) else changeset end end @doc """ Confirms the account by setting `confirmed_at`. """ def confirm_changeset(<%= schema.singular %>) do <%= case schema.timestamp_type do %> <% :naive_datetime -> %>now = NaiveDateTime.utc_now(:second) <% :utc_datetime -> %>now = DateTime.utc_now(:second) <% :utc_datetime_usec -> %>now = DateTime.utc_now(:microsecond) <% end %>change(<%= schema.singular %>, confirmed_at: now) end @doc """ Verifies the password. If there is no <%= schema.singular %> or the <%= schema.singular %> doesn't have a password, we call `<%= inspect hashing_library.module %>.no_user_verify/0` to avoid timing attacks. """ def valid_password?(%<%= inspect schema.module %>{hashed_password: hashed_password}, password) when is_binary(hashed_password) and byte_size(password) > 0 do <%= inspect hashing_library.module %>.verify_pass(password, hashed_password) end def valid_password?(_, _) do <%= inspect hashing_library.module %>.no_user_verify() false end end ================================================ FILE: priv/templates/phx.gen.auth/schema_token.ex.eex ================================================ defmodule <%= inspect schema.module %>Token do use Ecto.Schema import Ecto.Query alias <%= inspect schema.module %>Token @hash_algorithm :sha256 @rand_size 32 # It is very important to keep the magic link token expiry short, # since someone with access to the email may take over the account. @magic_link_validity_in_minutes 15 @change_email_validity_in_days 7 @session_validity_in_days 14 <%= if schema.binary_id do %> @primary_key {:id, :binary_id, autogenerate: true} @foreign_key_type :binary_id<% end %> schema "<%= schema.table %>_tokens" do field :token, :binary field :context, :string field :sent_to, :string field :authenticated_at, <%= inspect schema.timestamp_type %> belongs_to :<%= schema.singular %>, <%= inspect schema.module %> timestamps(<%= if schema.timestamp_type != :naive_datetime, do: "type: #{inspect schema.timestamp_type}, " %>updated_at: false) end @doc """ Generates a token that will be stored in a signed place, such as session or cookie. As they are signed, those tokens do not need to be hashed. The reason why we store session tokens in the database, even though Phoenix already provides a session cookie, is because Phoenix's default session cookies are not persisted, they are simply signed and potentially encrypted. This means they are valid indefinitely, unless you change the signing/encryption salt. Therefore, storing them allows individual <%= schema.singular %> sessions to be expired. The token system can also be extended to store additional data, such as the device used for logging in. You could then use this information to display all valid sessions and devices in the UI and allow users to explicitly expire any session they deem invalid. """ def build_session_token(<%= schema.singular %>) do token = :crypto.strong_rand_bytes(@rand_size) dt = <%= schema.singular %>.authenticated_at || <%= datetime_now %> {token, %<%= inspect schema.alias %>Token{token: token, context: "session", <%= schema.singular %>_id: <%= schema.singular %>.id, authenticated_at: dt}} end @doc """ Checks if the token is valid and returns its underlying lookup query. The query returns the <%= schema.singular %> found by the token, if any, along with the token's creation time. The token is valid if it matches the value in the database and it has not expired (after @session_validity_in_days). """ def verify_session_token_query(token) do query = from token in by_token_and_context_query(token, "session"), join: <%= schema.singular %> in assoc(token, :<%= schema.singular %>), where: token.inserted_at > ago(@session_validity_in_days, "day"), select: {%{<%= schema.singular %> | authenticated_at: token.authenticated_at}, token.inserted_at} {:ok, query} end @doc """ Builds a token and its hash to be delivered to the <%= schema.singular %>'s email. The non-hashed token is sent to the <%= schema.singular %> email while the hashed part is stored in the database. The original token cannot be reconstructed, which means anyone with read-only access to the database cannot directly use the token in the application to gain access. Furthermore, if the <%= schema.singular %> changes their email in the system, the tokens sent to the previous email are no longer valid. Users can easily adapt the existing code to provide other types of delivery methods, for example, by phone numbers. """ def build_email_token(<%= schema.singular %>, context) do build_hashed_token(<%= schema.singular %>, context, <%= schema.singular %>.email) end defp build_hashed_token(<%= schema.singular %>, context, sent_to) do token = :crypto.strong_rand_bytes(@rand_size) hashed_token = :crypto.hash(@hash_algorithm, token) {Base.url_encode64(token, padding: false), %<%= inspect schema.alias %>Token{ token: hashed_token, context: context, sent_to: sent_to, <%= schema.singular %>_id: <%= schema.singular %>.id }} end @doc """ Checks if the token is valid and returns its underlying lookup query. If found, the query returns a tuple of the form `{<%= schema.singular %>, token}`. The given token is valid if it matches its hashed counterpart in the database. This function also checks whether the token has expired. The context of a magic link token is always "login". """ def verify_magic_link_token_query(token) do case Base.url_decode64(token, padding: false) do {:ok, decoded_token} -> hashed_token = :crypto.hash(@hash_algorithm, decoded_token) query = from token in by_token_and_context_query(hashed_token, "login"), join: <%= schema.singular %> in assoc(token, :<%= schema.singular %>), where: token.inserted_at > ago(^@magic_link_validity_in_minutes, "minute"), where: token.sent_to == <%= schema.singular %>.email, select: {<%= schema.singular %>, token} {:ok, query} :error -> :error end end @doc """ Checks if the token is valid and returns its underlying lookup query. The query returns the <%= schema.singular %>_token found by the token, if any. This is used to validate requests to change the <%= schema.singular %> email. The given token is valid if it matches its hashed counterpart in the database and if it has not expired (after @change_email_validity_in_days). The context must always start with "change:". """ def verify_change_email_token_query(token, "change:" <> _ = context) do case Base.url_decode64(token, padding: false) do {:ok, decoded_token} -> hashed_token = :crypto.hash(@hash_algorithm, decoded_token) query = from token in by_token_and_context_query(hashed_token, context), where: token.inserted_at > ago(@change_email_validity_in_days, "day") {:ok, query} :error -> :error end end defp by_token_and_context_query(token, context) do from <%= inspect schema.alias %>Token, where: [token: ^token, context: ^context] end end ================================================ FILE: priv/templates/phx.gen.auth/scope.ex.eex ================================================ defmodule <%= inspect scope_config.scope.module %> do @moduledoc """ Defines the scope of the caller to be used throughout the app. The `<%= inspect scope_config.scope.module %>` allows public interfaces to receive information about the caller, such as if the call is initiated from an end-user, and if so, which user. Additionally, such a scope can carry fields such as "super user" or other privileges for use as authorization, or to ensure specific code paths can only be access for a given scope. It is useful for logging as well as for scoping pubsub subscriptions and broadcasts when a caller subscribes to an interface or performs a particular action. Feel free to extend the fields on this struct to fit the needs of growing application requirements. """ alias <%= inspect schema.module %> defstruct <%= schema.singular %>: nil @doc """ Creates a scope for the given <%= schema.singular %>. Returns nil if no <%= schema.singular %> is given. """ def for_<%= schema.singular %>(%<%= inspect schema.alias %>{} = <%= schema.singular %>) do %__MODULE__{<%= schema.singular %>: <%= schema.singular %>} end def for_<%= schema.singular %>(nil), do: nil end ================================================ FILE: priv/templates/phx.gen.auth/session_confirm.html.heex.eex ================================================ ={@<%= scope_config.scope.assign_key %>}>
<.header>Welcome {@<%= schema.singular %>.email}
<.form :if={!@<%= schema.singular %>.confirmed_at} for={@form} id="confirmation_form" action={~p"<%= schema.route_prefix %>/log-in?_action=confirmed"} phx-mounted={JS.focus_first()} > <.button name={@form[:remember_me].name} value="true" phx-disable-with="Confirming..." class="btn btn-primary w-full" > Confirm and stay logged in <.button phx-disable-with="Confirming..." class="btn btn-primary btn-soft w-full mt-2"> Confirm and log in only this time <.form :if={@<%= schema.singular %>.confirmed_at} for={@form} id="login_form" action={~p"<%= schema.route_prefix %>/log-in"} phx-mounted={JS.focus_first()} > <%%= if @<%= scope_config.scope.assign_key %> do %> <.button variant="primary" phx-disable-with="Logging in..." class="btn btn-primary w-full"> Log in <%% else %> <.button name={@form[:remember_me].name} value="true" phx-disable-with="Logging in..." class="btn btn-primary w-full" > Keep me logged in on this device <.button phx-disable-with="Logging in..." class="btn btn-primary btn-soft w-full mt-2"> Log me in only this time <%% end %>

.confirmed_at} class="alert alert-outline mt-8"> Tip: If you prefer passwords, you can enable them in the <%= schema.singular %> settings.

================================================ FILE: priv/templates/phx.gen.auth/session_controller.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>SessionController do use <%= inspect context.web_module %>, :controller alias <%= inspect context.module %> alias <%= inspect auth_module %><%= if live? do %> def create(conn, %{"_action" => "confirmed"} = params) do create(conn, params, "<%= schema.human_singular %> confirmed successfully.") end def create(conn, params) do create(conn, params, "Welcome back!") end # magic link login defp create(conn, %{"<%= schema.singular %>" => %{"token" => token} = <%= schema.singular %>_params}, info) do case <%= inspect context.alias %>.login_<%= schema.singular %>_by_magic_link(token) do {:ok, {<%= schema.singular %>, tokens_to_disconnect}} -> <%= inspect schema.alias %>Auth.disconnect_sessions(tokens_to_disconnect) conn |> put_flash(:info, info) |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, <%= schema.singular %>_params) _ -> conn |> put_flash(:error, "The link is invalid or it has expired.") |> redirect(to: ~p"<%= schema.route_prefix %>/log-in") end end # email + password login defp create(conn, %{"<%= schema.singular %>" => <%= schema.singular %>_params}, info) do %{"email" => email, "password" => password} = <%= schema.singular %>_params if <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password(email, password) do conn |> put_flash(:info, info) |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, <%= schema.singular %>_params) else # In order to prevent user enumeration attacks, don't disclose whether the email is registered. conn |> put_flash(:error, "Invalid email or password") |> put_flash(:email, String.slice(email, 0, 160)) |> redirect(to: ~p"<%= schema.route_prefix %>/log-in") end end def update_password(conn, %{"<%= schema.singular %>" => <%= schema.singular %>_params} = params) do <%= schema.singular %> = conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> true = <%= inspect context.alias %>.sudo_mode?(<%= schema.singular %>) {:ok, {_<%= schema.singular %>, expired_tokens}} = <%= inspect context.alias %>.update_<%= schema.singular %>_password(<%= schema.singular %>, <%= schema.singular %>_params) # disconnect all existing LiveViews with old sessions <%= inspect schema.alias %>Auth.disconnect_sessions(expired_tokens) conn |> put_session(:<%= schema.singular %>_return_to, ~p"<%= schema.route_prefix %>/settings") |> create(params, "Password updated successfully!") end<% else %> def new(conn, _params) do email = get_in(conn.assigns, [:<%= scope_config.scope.assign_key %>, Access.key(:<%= schema.singular %>), Access.key(:email)]) form = Phoenix.Component.to_form(%{"email" => email}, as: "<%= schema.singular %>") render(conn, :new, form: form) end # magic link login def create(conn, %{"<%= schema.singular %>" => %{"token" => token} = <%= schema.singular %>_params} = params) do info = case params do %{"_action" => "confirmed"} -> "<%= schema.human_singular %> confirmed successfully." _ -> "Welcome back!" end case <%= inspect context.alias %>.login_<%= schema.singular %>_by_magic_link(token) do {:ok, {<%= schema.singular %>, _expired_tokens}} -> conn |> put_flash(:info, info) |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, <%= schema.singular %>_params) {:error, :not_found} -> conn |> put_flash(:error, "The link is invalid or it has expired.") |> render(:new, form: Phoenix.Component.to_form(%{}, as: "<%= schema.singular %>")) end end # email + password login def create(conn, %{"<%= schema.singular %>" => %{"email" => email, "password" => password} = <%= schema.singular %>_params}) do if <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password(email, password) do conn |> put_flash(:info, "Welcome back!") |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>, <%= schema.singular %>_params) else form = Phoenix.Component.to_form(<%= schema.singular %>_params, as: "<%= schema.singular %>") # In order to prevent user enumeration attacks, don't disclose whether the email is registered. conn |> put_flash(:error, "Invalid email or password") |> render(:new, form: form) end end # magic link request def create(conn, %{"<%= schema.singular %>" => %{"email" => email}}) do if <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(email) do <%= inspect context.alias %>.deliver_login_instructions( <%= schema.singular %>, &url(~p"<%= schema.route_prefix %>/log-in/#{&1}") ) end info = "If your email is in our system, you will receive instructions for logging in shortly." conn |> put_flash(:info, info) |> redirect(to: ~p"<%= schema.route_prefix %>/log-in") end def confirm(conn, %{"token" => token}) do if <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>_by_magic_link_token(token) do form = Phoenix.Component.to_form(%{"token" => token}, as: "<%= schema.singular %>") conn |> assign(:<%= schema.singular %>, <%= schema.singular %>) |> assign(:form, form) |> render(:confirm) else conn |> put_flash(:error, "Magic link is invalid or it has expired.") |> redirect(to: ~p"<%= schema.route_prefix %>/log-in") end end<% end %> def delete(conn, _params) do conn |> put_flash(:info, "Logged out successfully.") |> <%= inspect schema.alias %>Auth.log_out_<%= schema.singular %>() end end ================================================ FILE: priv/templates/phx.gen.auth/session_controller_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>SessionControllerTest do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> import <%= inspect context.module %>Fixtures alias <%= inspect context.module %> setup do %{unconfirmed_<%= schema.singular %>: unconfirmed_<%= schema.singular %>_fixture(), <%= schema.singular %>: <%= schema.singular %>_fixture()} end<%= if not live? do %> describe "GET <%= schema.route_prefix %>/log-in" do test "renders login page", %{conn: conn} do conn = get(conn, ~p"<%= schema.route_prefix %>/log-in") response = html_response(conn, 200) assert response =~ "Log in" assert response =~ ~p"<%= schema.route_prefix %>/register" assert response =~ "Log in with email" end test "renders login page with email filled in (sudo mode)", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do html = conn |> log_in_<%= schema.singular %>(<%= schema.singular %>) |> get(~p"<%= schema.route_prefix %>/log-in") |> html_response(200) assert html =~ "You need to reauthenticate" refute html =~ "Register" assert html =~ "Log in with email" assert html =~ ~s(/log-in?mode=password") response = html_response(conn, 200) assert response =~ "Log in" assert response =~ ~p"<%= schema.route_prefix %>/register" assert response =~ "Log in with email" end end describe "GET <%= schema.route_prefix %>/log-in/:token" do test "renders confirmation page for unconfirmed <%= schema.singular %>", %{conn: conn, unconfirmed_<%= schema.singular %>: <%= schema.singular %>} do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) conn = get(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") assert html_response(conn, 200) =~ "Confirm and stay logged in" end test "renders login page for confirmed <%= schema.singular %>", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) conn = get(conn, ~p"<%= schema.route_prefix %>/log-in/#{token}") html = html_response(conn, 200) refute html =~ "Confirm my account" assert html =~ "Log in" end test "raises error for invalid token", %{conn: conn} do conn = get(conn, ~p"<%= schema.route_prefix %>/log-in/invalid-token") assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" assert Phoenix.Flash.get(conn.assigns.flash, :error) == "Magic link is invalid or it has expired." end end<% end %> describe "POST <%= schema.route_prefix %>/log-in - email and password" do test "logs the <%= schema.singular %> in", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %> = set_password(<%= schema.singular %>) conn = post(conn, ~p"<%= schema.route_prefix %>/log-in", %{ "<%= schema.singular %>" => %{"email" => <%= schema.singular %>.email, "password" => valid_<%= schema.singular %>_password()} }) assert get_session(conn, :<%= schema.singular %>_token) assert redirected_to(conn) == ~p"/" # Now do a logged in request and assert on the menu conn = get(conn, ~p"/") response = html_response(conn, 200) assert response =~ <%= schema.singular %>.email assert response =~ ~p"<%= schema.route_prefix %>/settings" assert response =~ ~p"<%= schema.route_prefix %>/log-out" end test "logs the <%= schema.singular %> in with remember me", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %> = set_password(<%= schema.singular %>) conn = post(conn, ~p"<%= schema.route_prefix %>/log-in", %{ "<%= schema.singular %>" => %{ "email" => <%= schema.singular %>.email, "password" => valid_<%= schema.singular %>_password(), "remember_me" => "true" } }) assert conn.resp_cookies["_<%= web_app_name %>_<%= schema.singular %>_remember_me"] assert redirected_to(conn) == ~p"/" end test "logs the <%= schema.singular %> in with return to", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %> = set_password(<%= schema.singular %>) conn = conn |> init_test_session(<%= schema.singular %>_return_to: "/foo/bar") |> post(~p"<%= schema.route_prefix %>/log-in", %{ "<%= schema.singular %>" => %{ "email" => <%= schema.singular %>.email, "password" => valid_<%= schema.singular %>_password() } }) assert redirected_to(conn) == "/foo/bar" assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Welcome back!" end test "<%= if live?, do: "redirects to login page", else: "emits error message" %> with invalid credentials", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = post(conn, ~p"<%= schema.route_prefix %>/log-in?mode=password", %{ "<%= schema.singular %>" => %{"email" => <%= schema.singular %>.email, "password" => "invalid_password"} }) <%= if live? do %>assert Phoenix.Flash.get(conn.assigns.flash, :error) == "Invalid email or password" assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in"<% else %>response = html_response(conn, 200) assert response =~ "Log in" assert response =~ "Invalid email or password"<% end %> end end describe "POST <%= schema.route_prefix %>/log-in - magic link" do <%= if not live? do %>test "sends magic link email when <%= schema.singular %> exists", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = post(conn, ~p"<%= schema.route_prefix %>/log-in", %{ "<%= schema.singular %>" => %{"email" => <%= schema.singular %>.email} }) assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "If your email is in our system" assert <%= inspect schema.repo %>.get_by!(<%= inspect context.alias %>.<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id).context == "login" end <% end %>test "logs the <%= schema.singular %> in", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do {token, _hashed_token} = generate_<%= schema.singular %>_magic_link_token(<%= schema.singular %>) conn = post(conn, ~p"<%= schema.route_prefix %>/log-in", %{ "<%= schema.singular %>" => %{"token" => token} }) assert get_session(conn, :<%= schema.singular %>_token) assert redirected_to(conn) == ~p"/" # Now do a logged in request and assert on the menu conn = get(conn, ~p"/") response = html_response(conn, 200) assert response =~ <%= schema.singular %>.email assert response =~ ~p"<%= schema.route_prefix %>/settings" assert response =~ ~p"<%= schema.route_prefix %>/log-out" end test "confirms unconfirmed <%= schema.singular %>", %{conn: conn, unconfirmed_<%= schema.singular %>: <%= schema.singular %>} do {token, _hashed_token} = generate_<%= schema.singular %>_magic_link_token(<%= schema.singular %>) refute <%= schema.singular %>.confirmed_at conn = post(conn, ~p"<%= schema.route_prefix %>/log-in", %{ "<%= schema.singular %>" => %{"token" => token}, "_action" => "confirmed" }) assert get_session(conn, :<%= schema.singular %>_token) assert redirected_to(conn) == ~p"/" assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "<%= schema.human_singular %> confirmed successfully." assert <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= schema.singular %>.id).confirmed_at # Now do a logged in request and assert on the menu conn = get(conn, ~p"/") response = html_response(conn, 200) assert response =~ <%= schema.singular %>.email assert response =~ ~p"<%= schema.route_prefix %>/settings" assert response =~ ~p"<%= schema.route_prefix %>/log-out" end test "<%= if live?, do: "redirects to login page", else: "emits error message" %> when magic link is invalid", %{conn: conn} do conn = post(conn, ~p"<%= schema.route_prefix %>/log-in", %{ "<%= schema.singular %>" => %{"token" => "invalid"} }) <%= if live? do %>assert Phoenix.Flash.get(conn.assigns.flash, :error) == "The link is invalid or it has expired." assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in"<% else %>assert html_response(conn, 200) =~ "The link is invalid or it has expired."<% end %> end end describe "DELETE <%= schema.route_prefix %>/log-out" do test "logs the <%= schema.singular %> out", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = conn |> log_in_<%= schema.singular %>(<%= schema.singular %>) |> delete(~p"<%= schema.route_prefix %>/log-out") assert redirected_to(conn) == ~p"/" refute get_session(conn, :<%= schema.singular %>_token) assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Logged out successfully" end test "succeeds even if the <%= schema.singular %> is not logged in", %{conn: conn} do conn = delete(conn, ~p"<%= schema.route_prefix %>/log-out") assert redirected_to(conn) == ~p"/" refute get_session(conn, :<%= schema.singular %>_token) assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Logged out successfully" end end end ================================================ FILE: priv/templates/phx.gen.auth/session_html.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>SessionHTML do use <%= inspect context.web_module %>, :html embed_templates "<%= schema.singular %>_session_html/*" defp local_mail_adapter? do Application.get_env(:<%= Mix.Phoenix.otp_app() %>, <%= inspect context.base_module %>.Mailer)[:adapter] == Swoosh.Adapters.Local end end ================================================ FILE: priv/templates/phx.gen.auth/session_new.html.heex.eex ================================================ ={@<%= scope_config.scope.assign_key %>}>
<.header>

Log in

<:subtitle> <%%= if @<%= scope_config.scope.assign_key %> do %> You need to reauthenticate to perform sensitive actions on your account. <%% else %> Don't have an account? <.link navigate={~p"<%= schema.route_prefix %>/register"} class="font-semibold text-brand hover:underline" phx-no-format >Sign up for an account now. <%% end %>
<.icon name="hero-information-circle" class="size-6 shrink-0" />

You are running the local mail adapter.

To see sent emails, visit <.link href="/dev/mailbox" class="underline">the mailbox page.

<.form :let={f} for={@form} as={:<%= schema.singular %>} id="login_form_magic" action={~p"<%= schema.route_prefix %>/log-in"}> <.input readonly={!!@<%= scope_config.scope.assign_key %>} field={f[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required phx-mounted={JS.focus()} /> <.button class="btn btn-primary w-full"> Log in with email
or
<.form :let={f} for={@form} as={:<%= schema.singular %>} id="login_form_password" action={~p"<%= schema.route_prefix %>/log-in"}> <.input readonly={!!@<%= scope_config.scope.assign_key %>} field={f[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required /> <.input field={f[:password]} type="password" label="Password" autocomplete="current-password" spellcheck="false" /> <.button class="btn btn-primary w-full" name={@form[:remember_me].name} value="true"> Log in and stay logged in <.button class="btn btn-primary btn-soft w-full mt-2"> Log in only this time
================================================ FILE: priv/templates/phx.gen.auth/settings_controller.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>SettingsController do use <%= inspect context.web_module %>, :controller alias <%= inspect context.module %> alias <%= inspect auth_module %> import <%= inspect auth_module %>, only: [require_sudo_mode: 2] plug :require_sudo_mode plug :assign_email_and_password_changesets def edit(conn, _params) do render(conn, :edit) end def update(conn, %{"action" => "update_email"} = params) do %{"<%= schema.singular %>" => <%= schema.singular %>_params} = params <%= schema.singular %> = conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> case <%= inspect context.alias %>.change_<%= schema.singular %>_email(<%= schema.singular %>, <%= schema.singular %>_params) do %{valid?: true} = changeset -> <%= inspect context.alias %>.deliver_<%= schema.singular %>_update_email_instructions( Ecto.Changeset.apply_action!(changeset, :insert), <%= schema.singular %>.email, &url(~p"<%= schema.route_prefix %>/settings/confirm-email/#{&1}") ) conn |> put_flash( :info, "A link to confirm your email change has been sent to the new address." ) |> redirect(to: ~p"<%= schema.route_prefix %>/settings") changeset -> render(conn, :edit, email_changeset: %{changeset | action: :insert}) end end def update(conn, %{"action" => "update_password"} = params) do %{"<%= schema.singular %>" => <%= schema.singular %>_params} = params <%= schema.singular %> = conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> case <%= inspect context.alias %>.update_<%= schema.singular %>_password(<%= schema.singular %>, <%= schema.singular %>_params) do {:ok, {<%= schema.singular %>, _}} -> conn |> put_flash(:info, "Password updated successfully.") |> put_session(:<%= schema.singular %>_return_to, ~p"<%= schema.route_prefix %>/settings") |> <%= inspect schema.alias %>Auth.log_in_<%= schema.singular %>(<%= schema.singular %>) {:error, changeset} -> render(conn, :edit, password_changeset: changeset) end end def confirm_email(conn, %{"token" => token}) do case <%= inspect context.alias %>.update_<%= schema.singular %>_email(conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>, token) do {:ok, _<%= schema.singular %>} -> conn |> put_flash(:info, "Email changed successfully.") |> redirect(to: ~p"<%= schema.route_prefix %>/settings") {:error, _} -> conn |> put_flash(:error, "Email change link is invalid or it has expired.") |> redirect(to: ~p"<%= schema.route_prefix %>/settings") end end defp assign_email_and_password_changesets(conn, _opts) do <%= schema.singular %> = conn.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> conn |> assign(:email_changeset, <%= inspect context.alias %>.change_<%= schema.singular %>_email(<%= schema.singular %>)) |> assign(:password_changeset, <%= inspect context.alias %>.change_<%= schema.singular %>_password(<%= schema.singular %>)) end end ================================================ FILE: priv/templates/phx.gen.auth/settings_controller_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>SettingsControllerTest do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> alias <%= inspect context.module %> import <%= inspect context.module %>Fixtures setup :register_and_log_in_<%= schema.singular %> describe "GET <%= schema.route_prefix %>/settings" do test "renders settings page", %{conn: conn} do conn = get(conn, ~p"<%= schema.route_prefix %>/settings") response = html_response(conn, 200) assert response =~ "Settings" end test "redirects if <%= schema.singular %> is not logged in" do conn = build_conn() conn = get(conn, ~p"<%= schema.route_prefix %>/settings") assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" end @tag token_authenticated_at: <%= inspect datetime_module %>.add(<%= datetime_now %>, -11, :minute) test "redirects if <%= schema.singular %> is not in sudo mode", %{conn: conn} do conn = get(conn, ~p"<%= schema.route_prefix %>/settings") assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" assert Phoenix.Flash.get(conn.assigns.flash, :error) == "You must re-authenticate to access this page." end end describe "PUT <%= schema.route_prefix %>/settings (change password form)" do test "updates the <%= schema.singular %> password and resets tokens", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do new_password_conn = put(conn, ~p"<%= schema.route_prefix %>/settings", %{ "action" => "update_password", "<%= schema.singular %>" => %{ "password" => "new valid password", "password_confirmation" => "new valid password" } }) assert redirected_to(new_password_conn) == ~p"<%= schema.route_prefix %>/settings" assert get_session(new_password_conn, :<%= schema.singular %>_token) != get_session(conn, :<%= schema.singular %>_token) assert Phoenix.Flash.get(new_password_conn.assigns.flash, :info) =~ "Password updated successfully" assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password(<%= schema.singular %>.email, "new valid password") end test "does not update password on invalid data", %{conn: conn} do old_password_conn = put(conn, ~p"<%= schema.route_prefix %>/settings", %{ "action" => "update_password", "<%= schema.singular %>" => %{ "password" => "too short", "password_confirmation" => "does not match" } }) response = html_response(old_password_conn, 200) assert response =~ "Settings" assert response =~ "should be at least 12 character(s)" assert response =~ "does not match password" assert get_session(old_password_conn, :<%= schema.singular %>_token) == get_session(conn, :<%= schema.singular %>_token) end end describe "PUT <%= schema.route_prefix %>/settings (change email form)" do @tag :capture_log test "updates the <%= schema.singular %> email", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = put(conn, ~p"<%= schema.route_prefix %>/settings", %{ "action" => "update_email", "<%= schema.singular %>" => %{"email" => unique_<%= schema.singular %>_email()} }) assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/settings" assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "A link to confirm your email" assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(<%= schema.singular %>.email) end test "does not update email on invalid data", %{conn: conn} do conn = put(conn, ~p"<%= schema.route_prefix %>/settings", %{ "action" => "update_email", "<%= schema.singular %>" => %{"email" => "with spaces"} }) response = html_response(conn, 200) assert response =~ "Settings" assert response =~ "must have the @ sign and no spaces" end end describe "GET <%= schema.route_prefix %>/settings/confirm-email/:token" do setup %{<%= schema.singular %>: <%= schema.singular %>} do email = unique_<%= schema.singular %>_email() token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_<%= schema.singular %>_update_email_instructions(%{<%= schema.singular %> | email: email}, <%= schema.singular %>.email, url) end) %{token: token, email: email} end test "updates the <%= schema.singular %> email once", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>, token: token, email: email} do conn = get(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/#{token}") assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/settings" assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Email changed successfully" refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(<%= schema.singular %>.email) assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(email) conn = get(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/#{token}") assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/settings" assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Email change link is invalid or it has expired" end test "does not update email with invalid token", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do conn = get(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/oops") assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/settings" assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Email change link is invalid or it has expired" assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(<%= schema.singular %>.email) end test "redirects if <%= schema.singular %> is not logged in", %{token: token} do conn = build_conn() conn = get(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/#{token}") assert redirected_to(conn) == ~p"<%= schema.route_prefix %>/log-in" end end end ================================================ FILE: priv/templates/phx.gen.auth/settings_edit.html.heex.eex ================================================ ={@<%= scope_config.scope.assign_key %>}>
<.header> Account Settings <:subtitle>Manage your account email address and password settings
<.form :let={f} for={@email_changeset} action={~p"<%= schema.route_prefix %>/settings"} id="update_email"> <.input field={f[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required /> <.button variant="primary" phx-disable-with="Changing...">Change Email
<.form :let={f} for={@password_changeset} action={~p"<%= schema.route_prefix %>/settings"} id="update_password"> <.input field={f[:password]} type="password" label="New password" autocomplete="new-password" spellcheck="false" required /> <.input field={f[:password_confirmation]} type="password" label="Confirm new password" autocomplete="new-password" spellcheck="false" required /> <.button variant="primary" phx-disable-with="Changing..."> Save Password ================================================ FILE: priv/templates/phx.gen.auth/settings_html.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>SettingsHTML do use <%= inspect context.web_module %>, :html embed_templates "<%= schema.singular %>_settings_html/*" end ================================================ FILE: priv/templates/phx.gen.auth/settings_live.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.Settings do use <%= inspect context.web_module %>, :live_view on_mount {<%= inspect auth_module %>, :require_sudo_mode} alias <%= inspect context.module %> @impl true def render(assigns) do ~H""" ={@<%= scope_config.scope.assign_key %>}>
<.header> Account Settings <:subtitle>Manage your account email address and password settings
<.form for={@email_form} id="email_form" phx-submit="update_email" phx-change="validate_email"> <.input field={@email_form[:email]} type="email" label="Email" autocomplete="username" spellcheck="false" required /> <.button variant="primary" phx-disable-with="Changing...">Change Email
<.form for={@password_form} id="password_form" action={~p"<%= schema.route_prefix %>/update-password"} method="post" phx-change="validate_password" phx-submit="update_password" phx-trigger-action={@trigger_submit} > <.input field={@password_form[:password]} type="password" label="New password" autocomplete="new-password" spellcheck="false" required /> <.input field={@password_form[:password_confirmation]} type="password" label="Confirm new password" autocomplete="new-password" spellcheck="false" /> <.button variant="primary" phx-disable-with="Saving..."> Save Password """ end @impl true def mount(%{"token" => token}, _session, socket) do socket = case <%= inspect context.alias %>.update_<%= schema.singular %>_email(socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %>, token) do {:ok, _<%= schema.singular %>} -> put_flash(socket, :info, "Email changed successfully.") {:error, _} -> put_flash(socket, :error, "Email change link is invalid or it has expired.") end {:ok, push_navigate(socket, to: ~p"<%= schema.route_prefix %>/settings")} end def mount(_params, _session, socket) do <%= schema.singular %> = socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> email_changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_email(<%= schema.singular %>, %{}, validate_unique: false) password_changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_password(<%= schema.singular %>, %{}, hash_password: false) socket = socket |> assign(:current_email, <%= schema.singular %>.email) |> assign(:email_form, to_form(email_changeset)) |> assign(:password_form, to_form(password_changeset)) |> assign(:trigger_submit, false) {:ok, socket} end @impl true def handle_event("validate_email", params, socket) do %{"<%= schema.singular %>" => <%= schema.singular %>_params} = params email_form = socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> |> <%= inspect context.alias %>.change_<%= schema.singular %>_email(<%= schema.singular %>_params, validate_unique: false) |> Map.put(:action, :validate) |> to_form() {:noreply, assign(socket, email_form: email_form)} end def handle_event("update_email", params, socket) do %{"<%= schema.singular %>" => <%= schema.singular %>_params} = params <%= schema.singular %> = socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> true = <%= inspect context.alias %>.sudo_mode?(<%= schema.singular %>) case <%= inspect context.alias %>.change_<%= schema.singular %>_email(<%= schema.singular %>, <%= schema.singular %>_params) do %{valid?: true} = changeset -> <%= inspect context.alias %>.deliver_<%= schema.singular %>_update_email_instructions( Ecto.Changeset.apply_action!(changeset, :insert), <%= schema.singular %>.email, &url(~p"<%= schema.route_prefix %>/settings/confirm-email/#{&1}") ) info = "A link to confirm your email change has been sent to the new address." {:noreply, socket |> put_flash(:info, info)} changeset -> {:noreply, assign(socket, :email_form, to_form(changeset, action: :insert))} end end def handle_event("validate_password", params, socket) do %{"<%= schema.singular %>" => <%= schema.singular %>_params} = params password_form = socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> |> <%= inspect context.alias %>.change_<%= schema.singular %>_password(<%= schema.singular %>_params, hash_password: false) |> Map.put(:action, :validate) |> to_form() {:noreply, assign(socket, password_form: password_form)} end def handle_event("update_password", params, socket) do %{"<%= schema.singular %>" => <%= schema.singular %>_params} = params <%= schema.singular %> = socket.assigns.<%= scope_config.scope.assign_key %>.<%= schema.singular %> true = <%= inspect context.alias %>.sudo_mode?(<%= schema.singular %>) case <%= inspect context.alias %>.change_<%= schema.singular %>_password(<%= schema.singular %>, <%= schema.singular %>_params) do %{valid?: true} = changeset -> {:noreply, assign(socket, trigger_submit: true, password_form: to_form(changeset))} changeset -> {:noreply, assign(socket, password_form: to_form(changeset, action: :insert))} end end end ================================================ FILE: priv/templates/phx.gen.auth/settings_live_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.SettingsTest do use <%= inspect context.web_module %>.ConnCase<%= test_case_options %> alias <%= inspect context.module %> import Phoenix.LiveViewTest import <%= inspect context.module %>Fixtures describe "Settings page" do test "renders settings page", %{conn: conn} do {:ok, _lv, html} = conn |> log_in_<%= schema.singular %>(<%= schema.singular %>_fixture()) |> live(~p"<%= schema.route_prefix %>/settings") assert html =~ "Change Email" assert html =~ "Save Password" end test "redirects if <%= schema.singular %> is not logged in", %{conn: conn} do assert {:error, redirect} = live(conn, ~p"<%= schema.route_prefix %>/settings") assert {:redirect, %{to: path, flash: flash}} = redirect assert path == ~p"<%= schema.route_prefix %>/log-in" assert %{"error" => "You must log in to access this page."} = flash end test "redirects if <%= schema.singular %> is not in sudo mode", %{conn: conn} do {:ok, conn} = conn |> log_in_<%= schema.singular %>(<%= schema.singular %>_fixture(), token_authenticated_at: <%= inspect datetime_module %>.add(<%= datetime_now %>, -11, :minute) ) |> live(~p"<%= schema.route_prefix %>/settings") |> follow_redirect(conn, ~p"<%= schema.route_prefix %>/log-in") assert conn.resp_body =~ "You must re-authenticate to access this page." end end describe "update email form" do setup %{conn: conn} do <%= schema.singular %> = <%= schema.singular %>_fixture() %{conn: log_in_<%= schema.singular %>(conn, <%= schema.singular %>), <%= schema.singular %>: <%= schema.singular %>} end test "updates the <%= schema.singular %> email", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do new_email = unique_<%= schema.singular %>_email() {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/settings") result = lv |> form("#email_form", %{ "<%= schema.singular %>" => %{"email" => new_email} }) |> render_submit() assert result =~ "A link to confirm your email" assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(<%= schema.singular %>.email) end test "renders errors with invalid data (phx-change)", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/settings") result = lv |> element("#email_form") |> render_change(%{ "action" => "update_email", "<%= schema.singular %>" => %{"email" => "with spaces"} }) assert result =~ "Change Email" assert result =~ "must have the @ sign and no spaces" end test "renders errors with invalid data (phx-submit)", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/settings") result = lv |> form("#email_form", %{ "<%= schema.singular %>" => %{"email" => <%= schema.singular %>.email} }) |> render_submit() assert result =~ "Change Email" assert result =~ "did not change" end end describe "update password form" do setup %{conn: conn} do <%= schema.singular %> = <%= schema.singular %>_fixture() %{conn: log_in_<%= schema.singular %>(conn, <%= schema.singular %>), <%= schema.singular %>: <%= schema.singular %>} end test "updates the <%= schema.singular %> password", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do new_password = valid_<%= schema.singular %>_password() {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/settings") form = form(lv, "#password_form", %{ "<%= schema.singular %>" => %{ "email" => <%= schema.singular %>.email, "password" => new_password, "password_confirmation" => new_password } }) render_submit(form) new_password_conn = follow_trigger_action(form, conn) assert redirected_to(new_password_conn) == ~p"<%= schema.route_prefix %>/settings" assert get_session(new_password_conn, :<%= schema.singular %>_token) != get_session(conn, :<%= schema.singular %>_token) assert Phoenix.Flash.get(new_password_conn.assigns.flash, :info) =~ "Password updated successfully" assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password(<%= schema.singular %>.email, new_password) end test "renders errors with invalid data (phx-change)", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/settings") result = lv |> element("#password_form") |> render_change(%{ "<%= schema.singular %>" => %{ "password" => "too short", "password_confirmation" => "does not match" } }) assert result =~ "Save Password" assert result =~ "should be at least 12 character(s)" assert result =~ "does not match password" end test "renders errors with invalid data (phx-submit)", %{conn: conn} do {:ok, lv, _html} = live(conn, ~p"<%= schema.route_prefix %>/settings") result = lv |> form("#password_form", %{ "<%= schema.singular %>" => %{ "password" => "too short", "password_confirmation" => "does not match" } }) |> render_submit() assert result =~ "Save Password" assert result =~ "should be at least 12 character(s)" assert result =~ "does not match password" end end describe "confirm email" do setup %{conn: conn} do <%= schema.singular %> = <%= schema.singular %>_fixture() email = unique_<%= schema.singular %>_email() token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_<%= schema.singular %>_update_email_instructions(%{<%= schema.singular %> | email: email}, <%= schema.singular %>.email, url) end) %{conn: log_in_<%= schema.singular %>(conn, <%= schema.singular %>), token: token, email: email, <%= schema.singular %>: <%= schema.singular %>} end test "updates the <%= schema.singular %> email once", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>, token: token, email: email} do {:error, redirect} = live(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/#{token}") assert {:live_redirect, %{to: path, flash: flash}} = redirect assert path == ~p"<%= schema.route_prefix %>/settings" assert %{"info" => message} = flash assert message == "Email changed successfully." refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(<%= schema.singular %>.email) assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(email) # use confirm token again {:error, redirect} = live(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/#{token}") assert {:live_redirect, %{to: path, flash: flash}} = redirect assert path == ~p"<%= schema.route_prefix %>/settings" assert %{"error" => message} = flash assert message == "Email change link is invalid or it has expired." end test "does not update email with invalid token", %{conn: conn, <%= schema.singular %>: <%= schema.singular %>} do {:error, redirect} = live(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/oops") assert {:live_redirect, %{to: path, flash: flash}} = redirect assert path == ~p"<%= schema.route_prefix %>/settings" assert %{"error" => message} = flash assert message == "Email change link is invalid or it has expired." assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(<%= schema.singular %>.email) end test "redirects if <%= schema.singular %> is not logged in", %{token: token} do conn = build_conn() {:error, redirect} = live(conn, ~p"<%= schema.route_prefix %>/settings/confirm-email/#{token}") assert {:redirect, %{to: path, flash: flash}} = redirect assert path == ~p"<%= schema.route_prefix %>/log-in" assert %{"error" => message} = flash assert message == "You must log in to access this page." end end end ================================================ FILE: priv/templates/phx.gen.auth/test_cases.exs.eex ================================================ import <%= inspect context.module %>Fixtures alias <%= inspect context.module %>.{<%= inspect schema.alias %>, <%= inspect schema.alias %>Token} describe "get_<%= schema.singular %>_by_email/1" do test "does not return the <%= schema.singular %> if the email does not exist" do refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_email("unknown@example.com") end test "returns the <%= schema.singular %> if the email exists" do %{id: id} = <%= schema.singular %> = <%= schema.singular %>_fixture() assert %<%= inspect schema.alias %>{id: ^id} = <%= inspect context.alias %>.get_<%= schema.singular %>_by_email(<%= schema.singular %>.email) end end describe "get_<%= schema.singular %>_by_email_and_password/2" do test "does not return the <%= schema.singular %> if the email does not exist" do refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password("unknown@example.com", "hello world!") end test "does not return the <%= schema.singular %> if the password is not valid" do <%= schema.singular %> = <%= schema.singular %>_fixture() |> set_password() refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password(<%= schema.singular %>.email, "invalid") end test "returns the <%= schema.singular %> if the email and password are valid" do %{id: id} = <%= schema.singular %> = <%= schema.singular %>_fixture() |> set_password() assert %<%= inspect schema.alias %>{id: ^id} = <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password(<%= schema.singular %>.email, valid_<%= schema.singular %>_password()) end end describe "get_<%= schema.singular %>!/1" do test "raises if id is invalid" do assert_raise Ecto.NoResultsError, fn -> <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= inspect schema.sample_id %>) end end test "returns the <%= schema.singular %> with the given id" do %{id: id} = <%= schema.singular %> = <%= schema.singular %>_fixture() assert %<%= inspect schema.alias %>{id: ^id} = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%=schema.singular %>.id) end end describe "register_<%= schema.singular %>/1" do test "requires email to be set" do {:error, changeset} = <%= inspect context.alias %>.register_<%= schema.singular %>(%{}) assert %{email: ["can't be blank"]} = errors_on(changeset) end test "validates email when given" do {:error, changeset} = <%= inspect context.alias %>.register_<%= schema.singular %>(%{email: "not valid"}) assert %{email: ["must have the @ sign and no spaces"]} = errors_on(changeset) end test "validates maximum values for email for security" do too_long = String.duplicate("db", 100) {:error, changeset} = <%= inspect context.alias %>.register_<%= schema.singular %>(%{email: too_long}) assert "should be at most 160 character(s)" in errors_on(changeset).email end test "validates email uniqueness" do %{email: email} = <%= schema.singular %>_fixture() {:error, changeset} = <%= inspect context.alias %>.register_<%= schema.singular %>(%{email: email}) assert "has already been taken" in errors_on(changeset).email # Now try with the uppercased email too, to check that email case is ignored. {:error, changeset} = <%= inspect context.alias %>.register_<%= schema.singular %>(%{email: String.upcase(email)}) assert "has already been taken" in errors_on(changeset).email end test "registers <%= schema.plural %> without password" do email = unique_<%= schema.singular %>_email() {:ok, <%= schema.singular %>} = <%= inspect context.alias %>.register_<%= schema.singular %>(valid_<%= schema.singular %>_attributes(email: email)) assert <%= schema.singular %>.email == email assert is_nil(<%= schema.singular %>.hashed_password) assert is_nil(<%= schema.singular %>.confirmed_at) assert is_nil(<%= schema.singular %>.password) end end describe "sudo_mode?/2" do test "validates the authenticated_at time" do now = <%= inspect datetime_module %>.utc_now() assert <%= inspect context.alias %>.sudo_mode?(%<%= inspect schema.alias %>{authenticated_at: <%= inspect datetime_module %>.utc_now()}) assert <%= inspect context.alias %>.sudo_mode?(%<%= inspect schema.alias %>{authenticated_at: <%= inspect datetime_module %>.add(now, -19, :minute)}) refute <%= inspect context.alias %>.sudo_mode?(%<%= inspect schema.alias %>{authenticated_at: <%= inspect datetime_module %>.add(now, -21, :minute)}) # minute override refute <%= inspect context.alias %>.sudo_mode?( %<%= inspect schema.alias %>{authenticated_at: <%= inspect datetime_module %>.add(now, -11, :minute)}, -10 ) # not authenticated refute <%= inspect context.alias %>.sudo_mode?(%<%= inspect schema.alias %>{}) end end describe "change_<%= schema.singular %>_email/3" do test "returns a <%= schema.singular %> changeset" do assert %Ecto.Changeset{} = changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_email(%<%= inspect schema.alias %>{}) assert changeset.required == [:email] end end describe "deliver_<%= schema.singular %>_update_email_instructions/3" do setup do %{<%= schema.singular %>: <%= schema.singular %>_fixture()} end test "sends token through notification", %{<%= schema.singular %>: <%= schema.singular %>} do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_<%= schema.singular %>_update_email_instructions(<%= schema.singular %>, "current@example.com", url) end) {:ok, token} = Base.url_decode64(token, padding: false) assert <%= schema.singular %>_token = Repo.get_by(<%= inspect schema.alias %>Token, token: :crypto.hash(:sha256, token)) assert <%= schema.singular %>_token.<%= schema.singular %>_id == <%= schema.singular %>.id assert <%= schema.singular %>_token.sent_to == <%= schema.singular %>.email assert <%= schema.singular %>_token.context == "change:current@example.com" end end describe "update_<%= schema.singular %>_email/2" do setup do <%= schema.singular %> = unconfirmed_<%= schema.singular %>_fixture() email = unique_<%= schema.singular %>_email() token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_<%= schema.singular %>_update_email_instructions(%{<%= schema.singular %> | email: email}, <%= schema.singular %>.email, url) end) %{<%= schema.singular %>: <%= schema.singular %>, token: token, email: email} end test "updates the email with a valid token", %{<%= schema.singular %>: <%= schema.singular %>, token: token, email: email} do assert {:ok, %{email: ^email}} = <%= inspect context.alias %>.update_<%= schema.singular %>_email(<%= schema.singular %>, token) changed_<%= schema.singular %> = Repo.get!(<%= inspect schema.alias %>, <%= schema.singular %>.id) assert changed_<%= schema.singular %>.email != <%= schema.singular %>.email assert changed_<%= schema.singular %>.email == email refute Repo.get_by(<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id) end test "does not update email with invalid token", %{<%= schema.singular %>: <%= schema.singular %>} do assert <%= inspect context.alias %>.update_<%= schema.singular %>_email(<%= schema.singular %>, "oops") == {:error, :transaction_aborted} assert Repo.get!(<%= inspect schema.alias %>, <%= schema.singular %>.id).email == <%= schema.singular %>.email assert Repo.get_by(<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id) end test "does not update email if <%= schema.singular %> email changed", %{<%= schema.singular %>: <%= schema.singular %>, token: token} do assert <%= inspect context.alias %>.update_<%= schema.singular %>_email(%{<%= schema.singular %> | email: "current@example.com"}, token) == {:error, :transaction_aborted} assert Repo.get!(<%= inspect schema.alias %>, <%= schema.singular %>.id).email == <%= schema.singular %>.email assert Repo.get_by(<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id) end test "does not update email if token expired", %{<%= schema.singular %>: <%= schema.singular %>, token: token} do {1, nil} = Repo.update_all(<%= inspect schema.alias %>Token, set: [inserted_at: ~N[2020-01-01 00:00:00]]) assert <%= inspect context.alias %>.update_<%= schema.singular %>_email(<%= schema.singular %>, token) == {:error, :transaction_aborted} assert Repo.get!(<%= inspect schema.alias %>, <%= schema.singular %>.id).email == <%= schema.singular %>.email assert Repo.get_by(<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id) end end describe "change_<%= schema.singular %>_password/3" do test "returns a <%= schema.singular %> changeset" do assert %Ecto.Changeset{} = changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_password(%<%= inspect schema.alias %>{}) assert changeset.required == [:password] end test "allows fields to be set" do changeset = <%= inspect context.alias %>.change_<%= schema.singular %>_password( %<%= inspect schema.alias %>{}, %{ "password" => "new valid password" }, hash_password: false ) assert changeset.valid? assert get_change(changeset, :password) == "new valid password" assert is_nil(get_change(changeset, :hashed_password)) end end describe "update_<%= schema.singular %>_password/2" do setup do %{<%= schema.singular %>: <%= schema.singular %>_fixture()} end test "validates password", %{<%= schema.singular %>: <%= schema.singular %>} do {:error, changeset} = <%= inspect context.alias %>.update_<%= schema.singular %>_password(<%= schema.singular %>, %{ password: "not valid", password_confirmation: "another" }) assert %{ password: ["should be at least 12 character(s)"], password_confirmation: ["does not match password"] } = errors_on(changeset) end test "validates maximum values for password for security", %{<%= schema.singular %>: <%= schema.singular %>} do too_long = String.duplicate("db", 100) {:error, changeset} = <%= inspect context.alias %>.update_<%= schema.singular %>_password(<%= schema.singular %>, %{password: too_long}) assert "should be at most 72 character(s)" in errors_on(changeset).password end test "updates the password", %{<%= schema.singular %>: <%= schema.singular %>} do {:ok, {<%= schema.singular %>, expired_tokens}} = <%= inspect context.alias %>.update_<%= schema.singular %>_password(<%= schema.singular %>, %{ password: "new valid password" }) assert expired_tokens == [] assert is_nil(<%= schema.singular %>.password) assert <%= inspect context.alias %>.get_<%= schema.singular %>_by_email_and_password(<%= schema.singular %>.email, "new valid password") end test "deletes all tokens for the given <%= schema.singular %>", %{<%= schema.singular %>: <%= schema.singular %>} do _ = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) {:ok, {_, _}} = <%= inspect context.alias %>.update_<%= schema.singular %>_password(<%= schema.singular %>, %{ password: "new valid password" }) refute Repo.get_by(<%= inspect schema.alias %>Token, <%= schema.singular %>_id: <%= schema.singular %>.id) end end describe "generate_<%= schema.singular %>_session_token/1" do setup do %{<%= schema.singular %>: <%= schema.singular %>_fixture()} end test "generates a token", %{<%= schema.singular %>: <%= schema.singular %>} do token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) assert <%= schema.singular %>_token = Repo.get_by(<%= inspect schema.alias %>Token, token: token) assert <%= schema.singular %>_token.context == "session" assert <%= schema.singular %>_token.authenticated_at != nil # Creating the same token for another <%= schema.singular %> should fail assert_raise Ecto.ConstraintError, fn -> Repo.insert!(%<%= inspect schema.alias %>Token{ token: <%= schema.singular %>_token.token, <%= schema.singular %>_id: <%= schema.singular %>_fixture().id, context: "session" }) end end test "duplicates the authenticated_at of given <%= schema.singular %> in new token", %{<%= schema.singular %>: <%= schema.singular %>} do <%= schema.singular %> = %{<%= schema.singular %> | authenticated_at: <%= inspect datetime_module %>.add(<%= datetime_now %>, -3600)} token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) assert <%= schema.singular %>_token = Repo.get_by(<%= inspect schema.alias %>Token, token: token) assert <%= schema.singular %>_token.authenticated_at == <%= schema.singular %>.authenticated_at assert <%= inspect datetime_module %>.compare(<%= schema.singular %>_token.inserted_at, <%= schema.singular %>.authenticated_at) == :gt end end describe "get_<%= schema.singular %>_by_session_token/1" do setup do <%= schema.singular %> = <%= schema.singular %>_fixture() token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) %{<%= schema.singular %>: <%= schema.singular %>, token: token} end test "returns <%= schema.singular %> by token", %{<%= schema.singular %>: <%= schema.singular %>, token: token} do assert {session_<%= schema.singular %>, token_inserted_at} = <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(token) assert session_<%= schema.singular %>.id == <%= schema.singular %>.id assert session_<%= schema.singular %>.authenticated_at != nil assert token_inserted_at != nil end test "does not return <%= schema.singular %> for invalid token" do refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token("oops") end test "does not return <%= schema.singular %> for expired token", %{token: token} do dt = ~N[2020-01-01 00:00:00] {1, nil} = Repo.update_all(<%= inspect schema.alias %>Token, set: [inserted_at: dt, authenticated_at: dt]) refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(token) end end describe "get_<%= schema.singular %>_by_magic_link_token/1" do setup do <%= schema.singular %> = <%= schema.singular %>_fixture() {encoded_token, _hashed_token} = generate_<%= schema.singular %>_magic_link_token(<%= schema.singular %>) %{<%= schema.singular %>: <%= schema.singular %>, token: encoded_token} end test "returns <%= schema.singular %> by token", %{<%= schema.singular %>: <%= schema.singular %>, token: token} do assert session_<%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>_by_magic_link_token(token) assert session_<%= schema.singular %>.id == <%= schema.singular %>.id end test "does not return <%= schema.singular %> for invalid token" do refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_magic_link_token("oops") end test "does not return <%= schema.singular %> for expired token", %{token: token} do {1, nil} = Repo.update_all(<%= inspect schema.alias %>Token, set: [inserted_at: ~N[2020-01-01 00:00:00]]) refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_magic_link_token(token) end end describe "login_<%= schema.singular %>_by_magic_link/1" do test "confirms <%= schema.singular %> and expires tokens" do <%= schema.singular %> = unconfirmed_<%= schema.singular %>_fixture() refute <%= schema.singular %>.confirmed_at {encoded_token, hashed_token} = generate_<%= schema.singular %>_magic_link_token(<%= schema.singular %>) assert {:ok, {<%= schema.singular %>, [%{token: ^hashed_token}]}} = <%= inspect context.alias %>.login_<%= schema.singular %>_by_magic_link(encoded_token) assert <%= schema.singular %>.confirmed_at end test "returns <%= schema.singular %> and (deleted) token for confirmed <%= schema.singular %>" do <%= schema.singular %> = <%= schema.singular %>_fixture() assert <%= schema.singular %>.confirmed_at {encoded_token, _hashed_token} = generate_<%= schema.singular %>_magic_link_token(<%= schema.singular %>) assert {:ok, {^<%= schema.singular %>, []}} = <%= inspect context.alias %>.login_<%= schema.singular %>_by_magic_link(encoded_token) # one time use only assert {:error, :not_found} = <%= inspect context.alias %>.login_<%= schema.singular %>_by_magic_link(encoded_token) end test "raises when unconfirmed <%= schema.singular %> has password set" do <%= schema.singular %> = unconfirmed_<%= schema.singular %>_fixture() {1, nil} = Repo.update_all(<%= inspect schema.alias %>, set: [hashed_password: "hashed"]) {encoded_token, _hashed_token} = generate_<%= schema.singular %>_magic_link_token(<%= schema.singular %>) assert_raise RuntimeError, ~r/magic link log in is not allowed/, fn -> <%= inspect context.alias %>.login_<%= schema.singular %>_by_magic_link(encoded_token) end end end describe "delete_<%= schema.singular %>_session_token/1" do test "deletes the token" do <%= schema.singular %> = <%= schema.singular %>_fixture() token = <%= inspect context.alias %>.generate_<%= schema.singular %>_session_token(<%= schema.singular %>) assert <%= inspect context.alias %>.delete_<%= schema.singular %>_session_token(token) == :ok refute <%= inspect context.alias %>.get_<%= schema.singular %>_by_session_token(token) end end describe "deliver_login_instructions/2" do setup do %{<%= schema.singular %>: unconfirmed_<%= schema.singular %>_fixture()} end test "sends token through notification", %{<%= schema.singular %>: <%= schema.singular %>} do token = extract_<%= schema.singular %>_token(fn url -> <%= inspect context.alias %>.deliver_login_instructions(<%= schema.singular %>, url) end) {:ok, token} = Base.url_decode64(token, padding: false) assert <%= schema.singular %>_token = Repo.get_by(<%= inspect schema.alias %>Token, token: :crypto.hash(:sha256, token)) assert <%= schema.singular %>_token.<%= schema.singular %>_id == <%= schema.singular %>.id assert <%= schema.singular %>_token.sent_to == <%= schema.singular %>.email assert <%= schema.singular %>_token.context == "login" end end describe "inspect/2 for the <%= inspect schema.alias %> module" do test "does not include password" do refute inspect(%<%= inspect schema.alias %>{password: "123456"}) =~ "password: \"123456\"" end end ================================================ FILE: priv/templates/phx.gen.channel/channel.ex.eex ================================================ defmodule <%= module %>Channel do use <%= web_module %>, :channel @impl true def join("<%= singular %>:lobby", payload, socket) do if authorized?(payload) do {:ok, socket} else {:error, %{reason: "unauthorized"}} end end # Channels can be used in a request/response fashion # by sending replies to requests from the client @impl true def handle_in("ping", payload, socket) do {:reply, {:ok, payload}, socket} end # It is also common to receive messages from the client and # broadcast to everyone in the current topic (<%= singular %>:lobby). @impl true def handle_in("shout", payload, socket) do broadcast(socket, "shout", payload) {:noreply, socket} end # Add authorization logic here as required. defp authorized?(_payload) do true end end ================================================ FILE: priv/templates/phx.gen.channel/channel_case.ex.eex ================================================ defmodule <%= web_module %>.ChannelCase do @moduledoc """ This module defines the test case to be used by channel tests. Such tests rely on `Phoenix.ChannelTest` 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 <%= web_module %>.ChannelCase, async: true`, although this option is not recommended for other databases. """ use ExUnit.CaseTemplate using do quote do # Import conveniences for testing with channels import Phoenix.ChannelTest import <%= web_module %>.ChannelCase # The default endpoint for testing @endpoint <%= web_module %>.Endpoint end end<%= if Code.ensure_loaded?(Ecto.Adapters.SQL) do %> setup tags do <%= base %>.DataCase.setup_sandbox(tags) :ok end<% else %> setup _tags do :ok end<% end %> end ================================================ FILE: priv/templates/phx.gen.channel/channel_test.exs.eex ================================================ defmodule <%= module %>ChannelTest do use <%= web_module %>.ChannelCase setup do {:ok, _, socket} = <%= web_module %>.UserSocket |> socket("user_id", %{some: :assign}) |> subscribe_and_join(<%= module %>Channel, "<%= singular %>:lobby") %{socket: socket} end test "ping replies with status ok", %{socket: socket} do ref = push(socket, "ping", %{"hello" => "there"}) assert_reply ref, :ok, %{"hello" => "there"} end test "shout broadcasts to <%= singular %>:lobby", %{socket: socket} do push(socket, "shout", %{"hello" => "all"}) assert_broadcast "shout", %{"hello" => "all"} end test "broadcasts are pushed to the client", %{socket: socket} do broadcast_from!(socket, "broadcast", %{"some" => "data"}) assert_push "broadcast", %{"some" => "data"} end end ================================================ FILE: priv/templates/phx.gen.context/access_no_schema.ex.eex ================================================ alias <%= inspect schema.module %> @doc """ Returns the list of <%= schema.plural %>. ## Examples iex> list_<%= schema.plural %>() [%<%= inspect schema.alias %>{}, ...] """ def list_<%= schema.plural %> do raise "TODO" end @doc """ Gets a single <%= schema.singular %>. Raises if the <%= schema.human_singular %> does not exist. ## Examples iex> get_<%= schema.singular %>!(123) %<%= inspect schema.alias %>{} """ def get_<%= schema.singular %>!(<%= primary_key %>), do: raise "TODO" @doc """ Creates a <%= schema.singular %>. ## Examples iex> create_<%= schema.singular %>(%{field: value}) {:ok, %<%= inspect schema.alias %>{}} iex> create_<%= schema.singular %>(%{field: bad_value}) {:error, ...} """ def create_<%= schema.singular %>(attrs) do raise "TODO" end @doc """ Updates a <%= schema.singular %>. ## Examples iex> update_<%= schema.singular %>(<%= schema.singular %>, %{field: new_value}) {:ok, %<%= inspect schema.alias %>{}} iex> update_<%= schema.singular %>(<%= schema.singular %>, %{field: bad_value}) {:error, ...} """ def update_<%= schema.singular %>(%<%= inspect schema.alias %>{} = <%= schema.singular %>, attrs) do raise "TODO" end @doc """ Deletes a <%= inspect schema.alias %>. ## Examples iex> delete_<%= schema.singular %>(<%= schema.singular %>) {:ok, %<%= inspect schema.alias %>{}} iex> delete_<%= schema.singular %>(<%= schema.singular %>) {:error, ...} """ def delete_<%= schema.singular %>(%<%= inspect schema.alias %>{} = <%= schema.singular %>) do raise "TODO" end @doc """ Returns a data structure for tracking <%= schema.singular %> changes. ## Examples iex> change_<%= schema.singular %>(<%= schema.singular %>) %Todo{...} """ def change_<%= schema.singular %>(%<%= inspect schema.alias %>{} = <%= schema.singular %>, _attrs \\ %{}) do raise "TODO" end ================================================ FILE: priv/templates/phx.gen.context/access_no_schema_scope.ex.eex ================================================ alias <%= inspect schema.module %> alias <%= inspect scope.alias %> @doc """ Subscribes to scoped notifications about any <%= schema.singular %> changes. """ def subscribe_<%= schema.singular %>(%<%= inspect scope.alias %>{} = _scope) do raise "TODO" end @doc """ Returns the list of <%= schema.plural %>. ## Examples iex> list_<%= schema.plural %>(scope) [%<%= inspect schema.alias %>{}, ...] """ def list_<%= schema.plural %>(%<%= inspect scope.alias %>{} = _scope) do raise "TODO" end @doc """ Gets a single <%= schema.singular %>. Raises if the <%= schema.human_singular %> does not exist. ## Examples iex> get_<%= schema.singular %>!(scope, 123) %<%= inspect schema.alias %>{} """ def get_<%= schema.singular %>!(%<%= inspect scope.alias %>{} = _scope, id), do: raise "TODO" @doc """ Creates a <%= schema.singular %>. ## Examples iex> create_<%= schema.singular %>(scope, %{field: value}) {:ok, %<%= inspect schema.alias %>{}} iex> create_<%= schema.singular %>(scope, %{field: bad_value}) {:error, ...} """ def create_<%= schema.singular %>(%<%= inspect scope.alias %>{} = _scope, attrs) do raise "TODO" end @doc """ Updates a <%= schema.singular %>. ## Examples iex> update_<%= schema.singular %>(scope, <%= schema.singular %>, %{field: new_value}) {:ok, %<%= inspect schema.alias %>{}} iex> update_<%= schema.singular %>(scope, <%= schema.singular %>, %{field: bad_value}) {:error, ...} """ def update_<%= schema.singular %>(%<%= inspect scope.alias %>{} = _scope, %<%= inspect schema.alias %>{} = <%= schema.singular %>, attrs) do raise "TODO" end @doc """ Deletes a <%= inspect schema.alias %>. ## Examples iex> delete_<%= schema.singular %>(scope, <%= schema.singular %>) {:ok, %<%= inspect schema.alias %>{}} iex> delete_<%= schema.singular %>(scope, <%= schema.singular %>) {:error, ...} """ def delete_<%= schema.singular %>(%<%= inspect scope.alias %>{} = _scope, %<%= inspect schema.alias %>{} = <%= schema.singular %>) do raise "TODO" end @doc """ Returns a data structure for tracking <%= schema.singular %> changes. ## Examples iex> change_<%= schema.singular %>(scope, <%= schema.singular %>) %Todo{...} """ def change_<%= schema.singular %>(%<%= inspect scope.alias %>{} = _scope, %<%= inspect schema.alias %>{} = <%= schema.singular %>, _attrs \\ %{}) do raise "TODO" end ================================================ FILE: priv/templates/phx.gen.context/context.ex.eex ================================================ defmodule <%= inspect context.module %> do @moduledoc """ The <%= context.name %> context. """ import Ecto.Query, warn: false alias <%= inspect schema.repo %><%= schema.repo_alias %> end ================================================ FILE: priv/templates/phx.gen.context/context_test.exs.eex ================================================ defmodule <%= inspect context.module %>Test do use <%= inspect context.base_module %>.DataCase alias <%= inspect context.module %> end ================================================ FILE: priv/templates/phx.gen.context/fixtures.ex.eex ================================================ <%= for {attr, {_function_name, function_def, _needs_impl?}} <- schema.fixture_unique_functions do %> @doc """ Generate a unique <%= schema.singular %> <%= attr %>. """ <%= function_def %> <% end %> @doc """ Generate a <%= schema.singular %>. """ def <%= schema.singular %>_fixture(<%= if scope do %>scope, <% end %>attrs \\ %{}) do<%= if scope do %> attrs = Enum.into(attrs, %{ <%= schema.fixture_params |> Enum.map(fn {key, code} -> " #{key}: #{code}" end) |> Enum.join(",\n") %> }) {:ok, <%= schema.singular %>} = <%= inspect context.module %>.create_<%= schema.singular %>(scope, attrs)<% else %> {:ok, <%= schema.singular %>} = attrs |> Enum.into(%{ <%= schema.fixture_params |> Enum.map(fn {key, code} -> " #{key}: #{code}" end) |> Enum.join(",\n") %> }) |> <%= inspect context.module %>.create_<%= schema.singular %>() <% end %> <%= schema.singular %> end ================================================ FILE: priv/templates/phx.gen.context/fixtures_module.ex.eex ================================================ defmodule <%= inspect context.module %>Fixtures do @moduledoc """ This module defines test helpers for creating entities via the `<%= inspect context.module %>` context. """ end ================================================ FILE: priv/templates/phx.gen.context/schema_access.ex.eex ================================================ alias <%= inspect schema.module %> @doc """ Returns the list of <%= schema.plural %>. ## Examples iex> list_<%= schema.plural %>() [%<%= inspect schema.alias %>{}, ...] """ def list_<%= schema.plural %> do Repo.all(<%= inspect schema.alias %>) end @doc """ Gets a single <%= schema.singular %>. Raises `Ecto.NoResultsError` if the <%= schema.human_singular %> does not exist. ## Examples iex> get_<%= schema.singular %>!(123) %<%= inspect schema.alias %>{} iex> get_<%= schema.singular %>!(456) ** (Ecto.NoResultsError) """ def get_<%= schema.singular %>!(<%= primary_key %>), do: Repo.get!(<%= inspect schema.alias %>, <%= primary_key %>) @doc """ Creates a <%= schema.singular %>. ## Examples iex> create_<%= schema.singular %>(%{field: value}) {:ok, %<%= inspect schema.alias %>{}} iex> create_<%= schema.singular %>(%{field: bad_value}) {:error, %Ecto.Changeset{}} """ def create_<%= schema.singular %>(attrs) do %<%= inspect schema.alias %>{} |> <%= inspect schema.alias %>.changeset(attrs) |> Repo.insert() end @doc """ Updates a <%= schema.singular %>. ## Examples iex> update_<%= schema.singular %>(<%= schema.singular %>, %{field: new_value}) {:ok, %<%= inspect schema.alias %>{}} iex> update_<%= schema.singular %>(<%= schema.singular %>, %{field: bad_value}) {:error, %Ecto.Changeset{}} """ def update_<%= schema.singular %>(%<%= inspect schema.alias %>{} = <%= schema.singular %>, attrs) do <%= schema.singular %> |> <%= inspect schema.alias %>.changeset(attrs) |> Repo.update() end @doc """ Deletes a <%= schema.singular %>. ## Examples iex> delete_<%= schema.singular %>(<%= schema.singular %>) {:ok, %<%= inspect schema.alias %>{}} iex> delete_<%= schema.singular %>(<%= schema.singular %>) {:error, %Ecto.Changeset{}} """ def delete_<%= schema.singular %>(%<%= inspect schema.alias %>{} = <%= schema.singular %>) do Repo.delete(<%= schema.singular %>) end @doc """ Returns an `%Ecto.Changeset{}` for tracking <%= schema.singular %> changes. ## Examples iex> change_<%= schema.singular %>(<%= schema.singular %>) %Ecto.Changeset{data: %<%= inspect schema.alias %>{}} """ def change_<%= schema.singular %>(%<%= inspect schema.alias %>{} = <%= schema.singular %>, attrs \\ %{}) do <%= inspect schema.alias %>.changeset(<%= schema.singular %>, attrs) end ================================================ FILE: priv/templates/phx.gen.context/schema_access_scope.ex.eex ================================================ alias <%= inspect schema.module %> alias <%= inspect scope.module %> @doc """ Subscribes to scoped notifications about any <%= schema.singular %> changes. The broadcasted messages match the pattern: * {:created, %<%= inspect schema.alias %>{}} * {:updated, %<%= inspect schema.alias %>{}} * {:deleted, %<%= inspect schema.alias %>{}} """ def subscribe_<%= schema.plural %>(%<%= inspect scope.alias %>{} = scope) do key = scope.<%= Enum.join(scope.access_path, ".") %> Phoenix.PubSub.subscribe(<%= inspect context.base_module %>.PubSub, "<%= scope.name %>:#{key}:<%= schema.plural %>") end defp broadcast_<%= schema.singular %>(%<%= inspect scope.alias %>{} = scope, message) do key = scope.<%= Enum.join(scope.access_path, ".") %> Phoenix.PubSub.broadcast(<%= inspect context.base_module %>.PubSub, "<%= scope.name %>:#{key}:<%= schema.plural %>", message) end @doc """ Returns the list of <%= schema.plural %>. ## Examples iex> list_<%= schema.plural %>(scope) [%<%= inspect schema.alias %>{}, ...] """ def list_<%= schema.plural %>(%<%= inspect scope.alias %>{} = scope) do Repo.all_by(<%= inspect schema.alias %>, <%= scope.schema_key %>: scope.<%= Enum.join(scope.access_path, ".") %>) end @doc """ Gets a single <%= schema.singular %>. Raises `Ecto.NoResultsError` if the <%= schema.human_singular %> does not exist. ## Examples iex> get_<%= schema.singular %>!(scope, 123) %<%= inspect schema.alias %>{} iex> get_<%= schema.singular %>!(scope, 456) ** (Ecto.NoResultsError) """ def get_<%= schema.singular %>!(%<%= inspect scope.alias %>{} = scope, <%= primary_key %>) do Repo.get_by!(<%= inspect schema.alias %>, <%= primary_key %>: <%= primary_key %>, <%= scope.schema_key %>: scope.<%= Enum.join(scope.access_path, ".") %>) end @doc """ Creates a <%= schema.singular %>. ## Examples iex> create_<%= schema.singular %>(scope, %{field: value}) {:ok, %<%= inspect schema.alias %>{}} iex> create_<%= schema.singular %>(scope, %{field: bad_value}) {:error, %Ecto.Changeset{}} """ def create_<%= schema.singular %>(%<%= inspect scope.alias %>{} = scope, attrs) do with {:ok, <%= schema.singular %> = %<%= inspect schema.alias %>{}} <- %<%= inspect schema.alias %>{} |> <%= inspect schema.alias %>.changeset(attrs, scope) |> Repo.insert() do broadcast_<%= schema.singular %>(scope, {:created, <%= schema.singular %>}) {:ok, <%= schema.singular %>} end end @doc """ Updates a <%= schema.singular %>. ## Examples iex> update_<%= schema.singular %>(scope, <%= schema.singular %>, %{field: new_value}) {:ok, %<%= inspect schema.alias %>{}} iex> update_<%= schema.singular %>(scope, <%= schema.singular %>, %{field: bad_value}) {:error, %Ecto.Changeset{}} """ def update_<%= schema.singular %>(%<%= inspect scope.alias %>{} = scope, %<%= inspect schema.alias %>{} = <%= schema.singular %>, attrs) do true = <%= schema.singular %>.<%= scope.schema_key %> == scope.<%= Enum.join(scope.access_path, ".") %> with {:ok, <%= schema.singular %> = %<%= inspect schema.alias %>{}} <- <%= schema.singular %> |> <%= inspect schema.alias %>.changeset(attrs, scope) |> Repo.update() do broadcast_<%= schema.singular %>(scope, {:updated, <%= schema.singular %>}) {:ok, <%= schema.singular %>} end end @doc """ Deletes a <%= schema.singular %>. ## Examples iex> delete_<%= schema.singular %>(scope, <%= schema.singular %>) {:ok, %<%= inspect schema.alias %>{}} iex> delete_<%= schema.singular %>(scope, <%= schema.singular %>) {:error, %Ecto.Changeset{}} """ def delete_<%= schema.singular %>(%<%= inspect scope.alias %>{} = scope, %<%= inspect schema.alias %>{} = <%= schema.singular %>) do true = <%= schema.singular %>.<%= scope.schema_key %> == scope.<%= Enum.join(scope.access_path, ".") %> with {:ok, <%= schema.singular %> = %<%= inspect schema.alias %>{}} <- Repo.delete(<%= schema.singular %>) do broadcast_<%= schema.singular %>(scope, {:deleted, <%= schema.singular %>}) {:ok, <%= schema.singular %>} end end @doc """ Returns an `%Ecto.Changeset{}` for tracking <%= schema.singular %> changes. ## Examples iex> change_<%= schema.singular %>(scope, <%= schema.singular %>) %Ecto.Changeset{data: %<%= inspect schema.alias %>{}} """ def change_<%= schema.singular %>(%<%= inspect scope.alias %>{} = scope, %<%= inspect schema.alias %>{} = <%= schema.singular %>, attrs \\ %{}) do true = <%= schema.singular %>.<%= scope.schema_key %> == scope.<%= Enum.join(scope.access_path, ".") %> <%= inspect schema.alias %>.changeset(<%= schema.singular %>, attrs, scope) end ================================================ FILE: priv/templates/phx.gen.context/test_cases.exs.eex ================================================ describe "<%= schema.plural %>" do alias <%= inspect schema.module %> import <%= inspect context.module %>Fixtures @invalid_attrs <%= Mix.Phoenix.to_text for {key, _} <- schema.params.create, into: %{}, do: {key, nil} %> test "list_<%= schema.plural %>/0 returns all <%= schema.plural %>" do <%= schema.singular %> = <%= schema.singular %>_fixture() assert <%= inspect context.alias %>.list_<%= schema.plural %>() == [<%= schema.singular %>] end test "get_<%= schema.singular %>!/1 returns the <%= schema.singular %> with given id" do <%= schema.singular %> = <%= schema.singular %>_fixture() assert <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= schema.singular %>.<%= primary_key %>) == <%= schema.singular %> end test "create_<%= schema.singular %>/1 with valid data creates a <%= schema.singular %>" do valid_attrs = <%= Mix.Phoenix.to_text schema.params.create %> assert {:ok, %<%= inspect schema.alias %>{} = <%= schema.singular %>} = <%= inspect context.alias %>.create_<%= schema.singular %>(valid_attrs)<%= for {field, value} <- schema.params.create do %> assert <%= schema.singular %>.<%= field %> == <%= Mix.Phoenix.Schema.value(schema, field, value) %><% end %> end test "create_<%= schema.singular %>/1 with invalid data returns error changeset" do assert {:error, %Ecto.Changeset{}} = <%= inspect context.alias %>.create_<%= schema.singular %>(@invalid_attrs) end test "update_<%= schema.singular %>/2 with valid data updates the <%= schema.singular %>" do <%= schema.singular %> = <%= schema.singular %>_fixture() update_attrs = <%= Mix.Phoenix.to_text schema.params.update%> assert {:ok, %<%= inspect schema.alias %>{} = <%= schema.singular %>} = <%= inspect context.alias %>.update_<%= schema.singular %>(<%= schema.singular %>, update_attrs)<%= for {field, value} <- schema.params.update do %> assert <%= schema.singular %>.<%= field %> == <%= Mix.Phoenix.Schema.value(schema, field, value) %><% end %> end test "update_<%= schema.singular %>/2 with invalid data returns error changeset" do <%= schema.singular %> = <%= schema.singular %>_fixture() assert {:error, %Ecto.Changeset{}} = <%= inspect context.alias %>.update_<%= schema.singular %>(<%= schema.singular %>, @invalid_attrs) assert <%= schema.singular %> == <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= schema.singular %>.<%= primary_key %>) end test "delete_<%= schema.singular %>/1 deletes the <%= schema.singular %>" do <%= schema.singular %> = <%= schema.singular %>_fixture() assert {:ok, %<%= inspect schema.alias %>{}} = <%= inspect context.alias %>.delete_<%= schema.singular %>(<%= schema.singular %>) assert_raise Ecto.NoResultsError, fn -> <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= schema.singular %>.<%= primary_key %>) end end test "change_<%= schema.singular %>/1 returns a <%= schema.singular %> changeset" do <%= schema.singular %> = <%= schema.singular %>_fixture() assert %Ecto.Changeset{} = <%= inspect context.alias %>.change_<%= schema.singular %>(<%= schema.singular %>) end end ================================================ FILE: priv/templates/phx.gen.context/test_cases_scope.exs.eex ================================================ describe "<%= schema.plural %>" do alias <%= inspect schema.module %> import <%= inspect scope.test_data_fixture %>, only: [<%= scope.name %>_scope_fixture: 0] import <%= inspect context.module %>Fixtures @invalid_attrs <%= Mix.Phoenix.to_text for {key, _} <- schema.params.create, into: %{}, do: {key, nil} %> test "list_<%= schema.plural %>/1 returns all scoped <%= schema.plural %>" do scope = <%= scope.name %>_scope_fixture() other_scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) other_<%= schema.singular %> = <%= schema.singular %>_fixture(other_scope) assert <%= inspect context.alias %>.list_<%= schema.plural %>(scope) == [<%= schema.singular %>] assert <%= inspect context.alias %>.list_<%= schema.plural %>(other_scope) == [other_<%= schema.singular %>] end test "get_<%= schema.singular %>!/2 returns the <%= schema.singular %> with given id" do scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) other_scope = <%= scope.name %>_scope_fixture() assert <%= inspect context.alias %>.get_<%= schema.singular %>!(scope, <%= schema.singular %>.<%= schema.opts[:primary_key] || :id %>) == <%= schema.singular %> assert_raise Ecto.NoResultsError, fn -> <%= inspect context.alias %>.get_<%= schema.singular %>!(other_scope, <%= schema.singular %>.<%= schema.opts[:primary_key] || :id %>) end end test "create_<%= schema.singular %>/2 with valid data creates a <%= schema.singular %>" do valid_attrs = <%= Mix.Phoenix.to_text schema.params.create %> scope = <%= scope.name %>_scope_fixture() assert {:ok, %<%= inspect schema.alias %>{} = <%= schema.singular %>} = <%= inspect context.alias %>.create_<%= schema.singular %>(scope, valid_attrs)<%= for {field, value} <- schema.params.create do %> assert <%= schema.singular %>.<%= field %> == <%= Mix.Phoenix.Schema.value(schema, field, value) %><% end %> assert <%= schema.singular %>.<%= scope.schema_key %> == scope.<%= scope.access_path |> Enum.join(".") %> end test "create_<%= schema.singular %>/2 with invalid data returns error changeset" do scope = <%= scope.name %>_scope_fixture() assert {:error, %Ecto.Changeset{}} = <%= inspect context.alias %>.create_<%= schema.singular %>(scope, @invalid_attrs) end test "update_<%= schema.singular %>/3 with valid data updates the <%= schema.singular %>" do scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) update_attrs = <%= Mix.Phoenix.to_text schema.params.update%> assert {:ok, %<%= inspect schema.alias %>{} = <%= schema.singular %>} = <%= inspect context.alias %>.update_<%= schema.singular %>(scope, <%= schema.singular %>, update_attrs)<%= for {field, value} <- schema.params.update do %> assert <%= schema.singular %>.<%= field %> == <%= Mix.Phoenix.Schema.value(schema, field, value) %><% end %> end test "update_<%= schema.singular %>/3 with invalid scope raises" do scope = <%= scope.name %>_scope_fixture() other_scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) assert_raise MatchError, fn -> <%= inspect context.alias %>.update_<%= schema.singular %>(other_scope, <%= schema.singular %>, %{}) end end test "update_<%= schema.singular %>/3 with invalid data returns error changeset" do scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) assert {:error, %Ecto.Changeset{}} = <%= inspect context.alias %>.update_<%= schema.singular %>(scope, <%= schema.singular %>, @invalid_attrs) assert <%= schema.singular %> == <%= inspect context.alias %>.get_<%= schema.singular %>!(scope, <%= schema.singular %>.<%= schema.opts[:primary_key] || :id %>) end test "delete_<%= schema.singular %>/2 deletes the <%= schema.singular %>" do scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) assert {:ok, %<%= inspect schema.alias %>{}} = <%= inspect context.alias %>.delete_<%= schema.singular %>(scope, <%= schema.singular %>) assert_raise Ecto.NoResultsError, fn -> <%= inspect context.alias %>.get_<%= schema.singular %>!(scope, <%= schema.singular %>.<%= schema.opts[:primary_key] || :id %>) end end test "delete_<%= schema.singular %>/2 with invalid scope raises" do scope = <%= scope.name %>_scope_fixture() other_scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) assert_raise MatchError, fn -> <%= inspect context.alias %>.delete_<%= schema.singular %>(other_scope, <%= schema.singular %>) end end test "change_<%= schema.singular %>/2 returns a <%= schema.singular %> changeset" do scope = <%= scope.name %>_scope_fixture() <%= schema.singular %> = <%= schema.singular %>_fixture(scope) assert %Ecto.Changeset{} = <%= inspect context.alias %>.change_<%= schema.singular %>(scope, <%= schema.singular %>) end end ================================================ FILE: priv/templates/phx.gen.embedded/embedded_schema.ex.eex ================================================ defmodule <%= inspect schema.module %> do use Ecto.Schema import Ecto.Changeset alias <%= inspect schema.module %> embedded_schema do <%= if !Enum.empty?(schema.types) do %> <%= Mix.Phoenix.Schema.format_fields_for_schema(schema) %><% end %> <%= for {_, k, _, _} <- schema.assocs do %> field <%= inspect k %>, <%= if schema.binary_id do %>:binary_id<% else %>:id<% end %> <% end %> end @doc false def changeset(%<%= inspect schema.alias %>{} = <%= schema.singular %>, attrs) do <%= schema.singular %> |> cast(attrs, [<%= Enum.map_join(schema.attrs, ", ", &inspect(elem(&1, 0))) %>]) |> validate_required([<%= Enum.map_join(schema.attrs, ", ", &inspect(elem(&1, 0))) %>]) end end ================================================ FILE: priv/templates/phx.gen.html/controller.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Controller do use <%= inspect context.web_module %>, :controller alias <%= inspect context.module %> alias <%= inspect schema.module %> def index(conn, _params) do <%= schema.plural %> = <%= inspect context.alias %>.list_<%= schema.plural %>(<%= conn_scope %>) render(conn, :index, <%= schema.collection %>: <%= schema.plural %>) end def new(conn, _params) do<%= if scope do %> changeset = <%= inspect context.alias %>.change_<%= schema.singular %>(<%= context_scope_prefix %>%<%= inspect schema.alias %>{ <%= scope.schema_key %>: <%= conn_scope %>.<%= Enum.join(scope.access_path, ".") %> }) <% else %> changeset = <%= inspect context.alias %>.change_<%= schema.singular %>(%<%= inspect schema.alias %>{})<% end %> render(conn, :new, changeset: changeset) end def create(conn, %{<%= inspect schema.singular %> => <%= schema.singular %>_params}) do case <%= inspect context.alias %>.create_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>_params) do {:ok, <%= schema.singular %>} -> conn |> put_flash(:info, "<%= schema.human_singular %> created successfully.") |> redirect(to: ~p"<%= scope_conn_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") {:error, %Ecto.Changeset{} = changeset} -> render(conn, :new, changeset: changeset) end end def show(conn, %{"<%= primary_key %>" => <%= primary_key %>}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) render(conn, :show, <%= schema.singular %>: <%= schema.singular %>) end def edit(conn, %{"<%= primary_key %>" => <%= primary_key %>}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) changeset = <%= inspect context.alias %>.change_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>) render(conn, :edit, <%= schema.singular %>: <%= schema.singular %>, changeset: changeset) end def update(conn, %{"<%= primary_key %>" => <%= primary_key %>, <%= inspect schema.singular %> => <%= schema.singular %>_params}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) case <%= inspect context.alias %>.update_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>, <%= schema.singular %>_params) do {:ok, <%= schema.singular %>} -> conn |> put_flash(:info, "<%= schema.human_singular %> updated successfully.") |> redirect(to: ~p"<%= scope_conn_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") {:error, %Ecto.Changeset{} = changeset} -> render(conn, :edit, <%= schema.singular %>: <%= schema.singular %>, changeset: changeset) end end def delete(conn, %{"<%= primary_key %>" => <%= primary_key %>}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) {:ok, _<%= schema.singular %>} = <%= inspect context.alias %>.delete_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>) conn |> put_flash(:info, "<%= schema.human_singular %> deleted successfully.") |> redirect(to: ~p"<%= scope_conn_route_prefix %><%= schema.route_prefix %>") end end ================================================ FILE: priv/templates/phx.gen.html/controller_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>ControllerTest do use <%= inspect context.web_module %>.ConnCase import <%= inspect context.module %>Fixtures @create_attrs <%= Mix.Phoenix.to_text schema.params.create %> @update_attrs <%= Mix.Phoenix.to_text schema.params.update %> @invalid_attrs <%= Mix.Phoenix.to_text (for {key, _} <- schema.params.create, into: %{}, do: {key, nil}) %><%= if scope do %> setup :<%= scope.test_setup_helper %><% end %> describe "index" do test "lists all <%= schema.plural %>", %{conn: conn<%= test_context_scope %>} do conn = get(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>") assert html_response(conn, 200) =~ "Listing <%= schema.human_plural %>" end end describe "new <%= schema.singular %>" do test "renders form", %{conn: conn<%= test_context_scope %>} do conn = get(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/new") assert html_response(conn, 200) =~ "New <%= schema.human_singular %>" end end describe "create <%= schema.singular %>" do test "redirects to show when data is valid", %{conn: conn<%= test_context_scope %>} do conn = post(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>", <%= schema.singular %>: @create_attrs) assert %{<%= primary_key %>: <%= primary_key %>} = redirected_params(conn) assert redirected_to(conn) == ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= primary_key %>}" conn = get(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= primary_key %>}") assert html_response(conn, 200) =~ "<%= schema.human_singular %> #{<%= primary_key %>}" end test "renders errors when data is invalid", %{conn: conn<%= test_context_scope %>} do conn = post(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>", <%= schema.singular %>: @invalid_attrs) assert html_response(conn, 200) =~ "New <%= schema.human_singular %>" end end describe "edit <%= schema.singular %>" do setup [:create_<%= schema.singular %>] test "renders form for editing chosen <%= schema.singular %>", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do conn = get(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}/edit") assert html_response(conn, 200) =~ "Edit <%= schema.human_singular %>" end end describe "update <%= schema.singular %>" do setup [:create_<%= schema.singular %>] test "redirects when data is valid", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do conn = put(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}", <%= schema.singular %>: @update_attrs) assert redirected_to(conn) == ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}" conn = get(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}")<%= if schema.string_attr do %> assert html_response(conn, 200) =~ <%= inspect Mix.Phoenix.Schema.default_param(schema, :update) %><% else %> assert html_response(conn, 200)<% end %> end test "renders errors when data is invalid", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do conn = put(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}", <%= schema.singular %>: @invalid_attrs) assert html_response(conn, 200) =~ "Edit <%= schema.human_singular %>" end end describe "delete <%= schema.singular %>" do setup [:create_<%= schema.singular %>] test "deletes chosen <%= schema.singular %>", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do conn = delete(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") assert redirected_to(conn) == ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>" assert_error_sent 404, fn -> get(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") end end end <%= if scope do %> defp create_<%= schema.singular %>(%{scope: scope}) do <%= schema.singular %> = <%= schema.singular %>_fixture(scope) <% else %> defp create_<%= schema.singular %>(_) do <%= schema.singular %> = <%= schema.singular %>_fixture() <% end %> %{<%= schema.singular %>: <%= schema.singular %>} end end ================================================ FILE: priv/templates/phx.gen.html/edit.html.heex.eex ================================================ <%= scope.assign_key %>={@<%= scope.assign_key %>}<% end %>> <.header> Edit <%= schema.human_singular %> {@<%= schema.singular %>.<%= primary_key %>} <:subtitle>Use this form to manage <%= schema.singular %> records in your database. <.<%= schema.singular %>_form changeset={@changeset} action={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{@<%= schema.singular %>}"} return_to={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>"} /> ================================================ FILE: priv/templates/phx.gen.html/html.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>HTML do use <%= inspect context.web_module %>, :html embed_templates "<%= schema.singular %>_html/*" @doc """ Renders a <%= schema.singular %> form. The form is defined in the template at <%= schema.singular %>_html/<%= schema.singular %>_form.html.heex """ attr :changeset, Ecto.Changeset, required: true attr :action, :string, required: true attr :return_to, :string, default: nil def <%= schema.singular %>_form(assigns) end ================================================ FILE: priv/templates/phx.gen.html/index.html.heex.eex ================================================ <%= scope.assign_key %>={@<%= scope.assign_key %>}<% end %>> <.header> Listing <%= schema.human_plural %> <:actions> <.button href={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/new"}> <.icon name="hero-plus" /> New <%= schema.human_singular %> <.table id="<%= schema.plural %>" rows={@<%= schema.collection %>} row_click={&JS.navigate(~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{&1}")}><%= for {k, _} <- schema.attrs do %> <:col :let={<%= schema.singular %>} label="<%= Phoenix.Naming.humanize(Atom.to_string(k)) %>">{<%= schema.singular %>.<%= k %>}<% end %> <:action :let={<%= schema.singular %>}>
<.link navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}"}>Show
<.link navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}/edit"}>Edit <:action :let={<%= schema.singular %>}> <.link href={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}"} method="delete" data-confirm="Are you sure?"> Delete ================================================ FILE: priv/templates/phx.gen.html/new.html.heex.eex ================================================ <%= scope.assign_key %>={@<%= scope.assign_key %>}<% end %>> <.header> New <%= schema.human_singular %> <:subtitle>Use this form to manage <%= schema.singular %> records in your database. <.<%= schema.singular %>_form changeset={@changeset} action={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>"} return_to={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>"} /> ================================================ FILE: priv/templates/phx.gen.html/resource_form.html.heex.eex ================================================ <.form :let={f} for={@changeset} action={@action}> <%= Mix.Tasks.Phx.Gen.Html.indent_inputs(inputs, 2) %>
<.button variant="primary">Save <%= schema.human_singular %> <.button :if={@return_to} href={@return_to}>Cancel
================================================ FILE: priv/templates/phx.gen.html/show.html.heex.eex ================================================ <%= scope.assign_key %>={@<%= scope.assign_key %>}<% end %>> <.header> <%= schema.human_singular %> {@<%= schema.singular %>.<%= primary_key %>} <:subtitle>This is a <%= schema.singular %> record from your database. <:actions> <.button navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>"}> <.icon name="hero-arrow-left" /> <.button variant="primary" navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{@<%= schema.singular %>}/edit?return_to=show"}> <.icon name="hero-pencil-square" /> Edit <%= schema.singular %> <.list><%= for {k, _} <- schema.attrs do %> <:item title="<%= Phoenix.Naming.humanize(Atom.to_string(k)) %>">{@<%= schema.singular %>.<%= k %>}<% end %> ================================================ FILE: priv/templates/phx.gen.json/changeset_json.ex.eex ================================================ defmodule <%= inspect context.web_module %>.ChangesetJSON do @doc """ Renders changeset errors. """<%= if core_components? do %> def error(%{changeset: changeset}) do # When encoded, the changeset returns its errors # as a JSON object. So we just pass it forward. %{errors: Ecto.Changeset.traverse_errors(changeset, &<%= inspect context.web_module %>.CoreComponents.translate_error/1)} end<% else %> def error(%{changeset: changeset}) do # When encoded, the changeset returns its errors # as a JSON object. So we just pass it forward. %{errors: Ecto.Changeset.traverse_errors(changeset, &translate_error/1)} end <%= if gettext? do %> defp translate_error({msg, opts}) do # set by Ecto and indicates we should also apply plural rules. if count = opts[:count] do Gettext.dngettext(<%= inspect context.web_module %>.Gettext, "errors", msg, msg, count, opts) else Gettext.dgettext(<%= inspect context.web_module %>.Gettext, "errors", msg, opts) end end <% else %> defp translate_error({msg, opts}) do # You can make use of gettext to translate error messages by # uncommenting and adjusting the following code: # if count = opts[:count] do # Gettext.dngettext(<%= inspect context.web_module %>.Gettext, "errors", msg, msg, count, opts) # else # Gettext.dgettext(<%= inspect context.web_module %>.Gettext, "errors", msg, opts) # end Enum.reduce(opts, msg, fn {key, value}, acc -> String.replace(acc, "%{#{key}}", fn _ -> to_string(value) end) end) end<% end %><% end %> end ================================================ FILE: priv/templates/phx.gen.json/controller.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Controller do use <%= inspect context.web_module %>, :controller alias <%= inspect context.module %> alias <%= inspect schema.module %> action_fallback <%= inspect context.web_module %>.FallbackController def index(conn, _params) do <%= schema.plural %> = <%= inspect context.alias %>.list_<%= schema.plural %>(<%= conn_scope %>) render(conn, :index, <%= schema.plural %>: <%= schema.plural %>) end def create(conn, %{<%= inspect schema.singular %> => <%= schema.singular %>_params}) do with {:ok, %<%= inspect schema.alias %>{} = <%= schema.singular %>} <- <%= inspect context.alias %>.create_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>_params) do conn |> put_status(:created) |> put_resp_header("location", ~p"<%= schema.api_route_prefix %><%= scope_conn_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") |> render(:show, <%= schema.singular %>: <%= schema.singular %>) end end def show(conn, %{"<%= primary_key %>" => <%= primary_key %>}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) render(conn, :show, <%= schema.singular %>: <%= schema.singular %>) end def update(conn, %{"<%= primary_key %>" => <%= primary_key %>, <%= inspect schema.singular %> => <%= schema.singular %>_params}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) with {:ok, %<%= inspect schema.alias %>{} = <%= schema.singular %>} <- <%= inspect context.alias %>.update_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>, <%= schema.singular %>_params) do render(conn, :show, <%= schema.singular %>: <%= schema.singular %>) end end def delete(conn, %{"<%= primary_key %>" => <%= primary_key %>}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) with {:ok, %<%= inspect schema.alias %>{}} <- <%= inspect context.alias %>.delete_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>) do send_resp(conn, :no_content, "") end end end ================================================ FILE: priv/templates/phx.gen.json/controller_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>ControllerTest do use <%= inspect context.web_module %>.ConnCase import <%= inspect context.module %>Fixtures alias <%= inspect schema.module %> @create_attrs %{ <%= schema.params.create |> Enum.map(fn {key, val} -> " #{key}: #{inspect(val)}" end) |> Enum.join(",\n") %> } @update_attrs %{ <%= schema.params.update |> Enum.map(fn {key, val} -> " #{key}: #{inspect(val)}" end) |> Enum.join(",\n") %> } @invalid_attrs <%= Mix.Phoenix.to_text for {key, _} <- schema.params.create, into: %{}, do: {key, nil} %><%= if scope do %> setup :<%= scope.test_setup_helper %><% end %> setup %{conn: conn} do {:ok, conn: put_req_header(conn, "accept", "application/json")} end describe "index" do test "lists all <%= schema.plural %>", %{conn: conn<%= test_context_scope %>} do conn = get(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>") assert json_response(conn, 200)["data"] == [] end end describe "create <%= schema.singular %>" do test "renders <%= schema.singular %> when data is valid", %{conn: conn<%= test_context_scope %>} do conn = post(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>", <%= schema.singular %>: @create_attrs) assert %{"<%= primary_key %>" => <%= primary_key %>} = json_response(conn, 201)["data"] conn = get(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= primary_key %>}") assert %{ "<%= primary_key %>" => ^<%= primary_key %><%= for {key, val} <- schema.params.create |> Phoenix.json_library().encode!() |> Phoenix.json_library().decode!() do %>, "<%= key %>" => <%= inspect(val) %><% end %> } = json_response(conn, 200)["data"] end test "renders errors when data is invalid", %{conn: conn<%= test_context_scope %>} do conn = post(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>", <%= schema.singular %>: @invalid_attrs) assert json_response(conn, 422)["errors"] != %{} end end describe "update <%= schema.singular %>" do setup [:create_<%= schema.singular %>] test "renders <%= schema.singular %> when data is valid", %{conn: conn, <%= schema.singular %>: %<%= inspect schema.alias %>{<%= primary_key %>: <%= primary_key %>} = <%= schema.singular %><%= test_context_scope %>} do conn = put(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}", <%= schema.singular %>: @update_attrs) assert %{"<%= primary_key %>" => ^<%= primary_key %>} = json_response(conn, 200)["data"] conn = get(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= primary_key %>}") assert %{ "<%= primary_key %>" => ^<%= primary_key %><%= for {key, val} <- schema.params.update |> Phoenix.json_library().encode!() |> Phoenix.json_library().decode!() do %>, "<%= key %>" => <%= inspect(val) %><% end %> } = json_response(conn, 200)["data"] end test "renders errors when data is invalid", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do conn = put(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}", <%= schema.singular %>: @invalid_attrs) assert json_response(conn, 422)["errors"] != %{} end end describe "delete <%= schema.singular %>" do setup [:create_<%= schema.singular %>] test "deletes chosen <%= schema.singular %>", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do conn = delete(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") assert response(conn, 204) assert_error_sent 404, fn -> get(conn, ~p"<%= schema.api_route_prefix %><%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") end end end <%= if scope do %> defp create_<%= schema.singular %>(%{scope: scope}) do <%= schema.singular %> = <%= schema.singular %>_fixture(scope) <% else %> defp create_<%= schema.singular %>(_) do <%= schema.singular %> = <%= schema.singular %>_fixture() <% end %> %{<%= schema.singular %>: <%= schema.singular %>} end end ================================================ FILE: priv/templates/phx.gen.json/fallback_controller.ex.eex ================================================ defmodule <%= inspect context.web_module %>.FallbackController do @moduledoc """ Translates controller action results into valid `Plug.Conn` responses. See `Phoenix.Controller.action_fallback/1` for more details. """ use <%= inspect context.web_module %>, :controller <%= if schema.generate? do %># This clause handles errors returned by Ecto's insert/update/delete. def call(conn, {:error, %Ecto.Changeset{} = changeset}) do conn |> put_status(:unprocessable_entity) |> put_view(json: <%= inspect context.web_module %>.ChangesetJSON) |> render(:error, changeset: changeset) end <% end %># This clause is an example of how to handle resources that cannot be found. def call(conn, {:error, :not_found}) do conn |> put_status(:not_found) |> put_view(html: <%= inspect context.web_module %>.ErrorHTML, json: <%= inspect context.web_module %>.ErrorJSON) |> render(:"404") end end ================================================ FILE: priv/templates/phx.gen.json/json.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>JSON do alias <%= inspect schema.module %> @doc """ Renders a list of <%= schema.plural %>. """ def index(%{<%= schema.plural %>: <%= schema.plural %>}) do %{data: for(<%= schema.singular %> <- <%= schema.plural %>, do: data(<%= schema.singular %>))} end @doc """ Renders a single <%= schema.singular %>. """ def show(%{<%= schema.singular %>: <%= schema.singular %>}) do %{data: data(<%= schema.singular %>)} end defp data(%<%= inspect schema.alias %>{} = <%= schema.singular %>) do %{ <%= [{primary_key, :id} | schema.attrs] |> Enum.map(fn {k, _} -> " #{k}: #{schema.singular}.#{k}" end) |> Enum.join(",\n") %> } end end ================================================ FILE: priv/templates/phx.gen.live/form.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.Form do use <%= inspect context.web_module %>, :live_view alias <%= inspect context.module %> alias <%= inspect schema.module %> @impl true def render(assigns) do ~H""" <%= scope.assign_key %>={@<%= scope.assign_key %>}<% end %>> <.header> {@page_title} <:subtitle>Use this form to manage <%= schema.singular %> records in your database. <.form for={@form} id="<%= schema.singular %>-form" phx-change="validate" phx-submit="save"> <%= Mix.Tasks.Phx.Gen.Html.indent_inputs(inputs, 8) %>
<.button phx-disable-with="Saving..." variant="primary">Save <%= schema.human_singular %> <.button navigate={return_path(<%= assign_scope_prefix %>@return_to, @<%= schema.singular %>)}>Cancel
""" end @impl true def mount(params, _session, socket) do {:ok, socket |> assign(:return_to, return_to(params["return_to"])) |> apply_action(socket.assigns.live_action, params)} end defp return_to("show"), do: "show" defp return_to(_), do: "index" defp apply_action(socket, :edit, %{"<%= primary_key %>" => <%= primary_key %>}) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) socket |> assign(:page_title, "Edit <%= schema.human_singular %>") |> assign(:<%= schema.singular %>, <%= schema.singular %>) |> assign(:form, to_form(<%= inspect context.alias %>.change_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>))) end defp apply_action(socket, :new, _params) do <%= schema.singular %> = %<%= inspect schema.alias %>{<%= if scope do %><%= scope.schema_key %>: <%= socket_scope %>.<%= Enum.join(scope.access_path, ".") %><% end %>} socket |> assign(:page_title, "New <%= schema.human_singular %>") |> assign(:<%= schema.singular %>, <%= schema.singular %>) |> assign(:form, to_form(<%= inspect context.alias %>.change_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>))) end @impl true def handle_event("validate", %{"<%= schema.singular %>" => <%= schema.singular %>_params}, socket) do changeset = <%= inspect context.alias %>.change_<%= schema.singular %>(<%= context_scope_prefix %>socket.assigns.<%= schema.singular %>, <%= schema.singular %>_params) {:noreply, assign(socket, form: to_form(changeset, action: :validate))} end def handle_event("save", %{"<%= schema.singular %>" => <%= schema.singular %>_params}, socket) do save_<%= schema.singular %>(socket, socket.assigns.live_action, <%= schema.singular %>_params) end defp save_<%= schema.singular %>(socket, :edit, <%= schema.singular %>_params) do case <%= inspect context.alias %>.update_<%= schema.singular %>(<%= context_scope_prefix %>socket.assigns.<%= schema.singular %>, <%= schema.singular %>_params) do {:ok, <%= schema.singular %>} -> {:noreply, socket |> put_flash(:info, "<%= schema.human_singular %> updated successfully") <%= if scope do %>|> push_navigate( to: return_path(<%= context_scope_prefix %>socket.assigns.return_to, <%= schema.singular %>) )}<% else %>|> push_navigate(to: return_path(socket.assigns.return_to, <%= schema.singular %>))}<% end %> {:error, %Ecto.Changeset{} = changeset} -> {:noreply, assign(socket, form: to_form(changeset))} end end defp save_<%= schema.singular %>(socket, :new, <%= schema.singular %>_params) do case <%= inspect context.alias %>.create_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>_params) do {:ok, <%= schema.singular %>} -> {:noreply, socket |> put_flash(:info, "<%= schema.human_singular %> created successfully") <%= if scope do %>|> push_navigate( to: return_path(<%= context_scope_prefix %>socket.assigns.return_to, <%= schema.singular %>) )}<% else %>|> push_navigate(to: return_path(socket.assigns.return_to, <%= schema.singular %>))}<% end %> {:error, %Ecto.Changeset{} = changeset} -> {:noreply, assign(socket, form: to_form(changeset))} end end defp return_path(<%= scope_param_prefix %>"index", _<%= schema.singular %>), do: ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>" defp return_path(<%= scope_param_prefix %>"show", <%= schema.singular %>), do: ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}" end ================================================ FILE: priv/templates/phx.gen.live/index.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.Index do use <%= inspect context.web_module %>, :live_view alias <%= inspect context.module %> @impl true def render(assigns) do ~H""" <%= scope.assign_key %>={@<%= scope.assign_key %>}<% end %>> <.header> Listing <%= schema.human_plural %> <:actions> <.button variant="primary" navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/new"}> <.icon name="hero-plus" /> New <%= schema.human_singular %> <.table id="<%= schema.plural %>" rows={@streams.<%= schema.collection %>} row_click={fn {_id, <%= schema.singular %>} -> JS.navigate(~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") end} ><%= for {k, _} <- schema.attrs do %> <:col :let={{_id, <%= schema.singular %>}} label="<%= Phoenix.Naming.humanize(Atom.to_string(k)) %>">{<%= schema.singular %>.<%= k %>}<% end %> <:action :let={{_id, <%= schema.singular %>}}>
<.link navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}"}>Show
<.link navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}/edit"}>Edit <:action :let={{id, <%= schema.singular %>}}> <.link phx-click={JS.push("delete", value: %{<%= primary_key %>: <%= schema.singular %>.<%= primary_key %>}) |> hide("##{id}")} data-confirm="Are you sure?" > Delete """ end @impl true def mount(_params, _session, socket) do<%= if scope do %> if connected?(socket) do <%= inspect context.alias %>.subscribe_<%= schema.plural %>(<%= socket_scope %>) end <% end %> {:ok, socket |> assign(:page_title, "Listing <%= schema.human_plural %>")<%= if primary_key != :id do %> |> stream_configure(:<%= schema.collection %>, dom_id: &"<%= schema.collection %>-#{&1.<%= primary_key %>}")<% end %> |> stream(:<%= schema.collection %>, list_<%= schema.plural %>(<%= socket_scope %>))} end @impl true def handle_event("delete", %{"<%= primary_key %>" => <%= primary_key %>}, socket) do <%= schema.singular %> = <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>) {:ok, _} = <%= inspect context.alias %>.delete_<%= schema.singular %>(<%= context_scope_prefix %><%= schema.singular %>) {:noreply, stream_delete(socket, :<%= schema.collection %>, <%= schema.singular %>)} end<%= if scope do %> @impl true def handle_info({type, %<%= inspect schema.module %>{}}, socket) when type in [:created, :updated, :deleted] do {:noreply, stream(socket, :<%= schema.collection %>, list_<%= schema.plural %>(<%= socket_scope %>), reset: true)} end<% end %> defp list_<%= schema.plural %>(<%= scope && scope.assign_key %>) do <%= inspect context.alias %>.list_<%= schema.plural %>(<%= scope && scope.assign_key %>) end end ================================================ FILE: priv/templates/phx.gen.live/live_test.exs.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>LiveTest do use <%= inspect context.web_module %>.ConnCase import Phoenix.LiveViewTest import <%= inspect context.module %>Fixtures @create_attrs <%= Mix.Phoenix.to_text for {key, value} <- schema.params.create, into: %{}, do: {key, Mix.Phoenix.Schema.live_form_value(value)} %> @update_attrs <%= Mix.Phoenix.to_text for {key, value} <- schema.params.update, into: %{}, do: {key, Mix.Phoenix.Schema.live_form_value(value)} %> @invalid_attrs <%= Mix.Phoenix.to_text for {key, value} <- schema.params.create, into: %{}, do: {key, value |> Mix.Phoenix.Schema.live_form_value() |> Mix.Phoenix.Schema.invalid_form_value()} %><%= if scope do %> setup :<%= scope.test_setup_helper %> defp create_<%= schema.singular %>(%{scope: scope}) do <%= schema.singular %> = <%= schema.singular %>_fixture(scope) <% else %> defp create_<%= schema.singular %>(_) do <%= schema.singular %> = <%= schema.singular %>_fixture() <% end %> %{<%= schema.singular %>: <%= schema.singular %>} end describe "Index" do setup [:create_<%= schema.singular %>] test "lists all <%= schema.plural %>", <%= if schema.string_attr do %>%{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>}<% else %>%{conn: conn<%= test_context_scope %>}<% end %> do {:ok, _index_live, html} = live(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>") assert html =~ "Listing <%= schema.human_plural %>"<%= if schema.string_attr do %> assert html =~ <%= schema.singular %>.<%= schema.string_attr %><% end %> end test "saves new <%= schema.singular %>", %{conn: conn<%= test_context_scope %>} do {:ok, index_live, _html} = live(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>") assert {:ok, form_live, _} = index_live |> element("a", "New <%= schema.human_singular %>") |> render_click() |> follow_redirect(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/new") assert render(form_live) =~ "New <%= schema.human_singular %>" assert form_live |> form("#<%= schema.singular %>-form", <%= schema.singular %>: @invalid_attrs) |> render_change() =~ "<%= Mix.Phoenix.Schema.failed_render_change_message(schema) %>" assert {:ok, index_live, _html} = form_live |> form("#<%= schema.singular %>-form", <%= schema.singular %>: @create_attrs) |> render_submit() |> follow_redirect(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>") html = render(index_live) assert html =~ "<%= schema.human_singular %> created successfully"<%= if schema.string_attr do %> assert html =~ "some <%= schema.string_attr %>"<% end %> end test "updates <%= schema.singular %> in listing", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do {:ok, index_live, _html} = live(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>") assert {:ok, form_live, _html} = index_live |> element("#<%= schema.collection %>-#{<%= schema.singular %>.<%= primary_key %>} a", "Edit") |> render_click() |> follow_redirect(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}/edit") assert render(form_live) =~ "Edit <%= schema.human_singular %>" assert form_live |> form("#<%= schema.singular %>-form", <%= schema.singular %>: @invalid_attrs) |> render_change() =~ "<%= Mix.Phoenix.Schema.failed_render_change_message(schema) %>" assert {:ok, index_live, _html} = form_live |> form("#<%= schema.singular %>-form", <%= schema.singular %>: @update_attrs) |> render_submit() |> follow_redirect(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>") html = render(index_live) assert html =~ "<%= schema.human_singular %> updated successfully"<%= if schema.string_attr do %> assert html =~ "some updated <%= schema.string_attr %>"<% end %> end test "deletes <%= schema.singular %> in listing", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do {:ok, index_live, _html} = live(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>") assert index_live |> element("#<%= schema.collection %>-#{<%= schema.singular %>.<%= primary_key %>} a", "Delete") |> render_click() refute has_element?(index_live, "#<%= schema.plural %>-#{<%= schema.singular %>.<%= primary_key %>}") end end describe "Show" do setup [:create_<%= schema.singular %>] test "displays <%= schema.singular %>", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do {:ok, _show_live, html} = live(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") assert html =~ "Show <%= schema.human_singular %>"<%= if schema.string_attr do %> assert html =~ <%= schema.singular %>.<%= schema.string_attr %><% end %> end test "updates <%= schema.singular %> and returns to show", %{conn: conn, <%= schema.singular %>: <%= schema.singular %><%= test_context_scope %>} do {:ok, show_live, _html} = live(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") assert {:ok, form_live, _} = show_live |> element("a", "Edit") |> render_click() |> follow_redirect(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}/edit?return_to=show") assert render(form_live) =~ "Edit <%= schema.human_singular %>" assert form_live |> form("#<%= schema.singular %>-form", <%= schema.singular %>: @invalid_attrs) |> render_change() =~ "<%= Mix.Phoenix.Schema.failed_render_change_message(schema) %>" assert {:ok, show_live, _html} = form_live |> form("#<%= schema.singular %>-form", <%= schema.singular %>: @update_attrs) |> render_submit() |> follow_redirect(conn, ~p"<%= scope_param_route_prefix %><%= schema.route_prefix %>/#{<%= schema.singular %>}") html = render(show_live) assert html =~ "<%= schema.human_singular %> updated successfully"<%= if schema.string_attr do %> assert html =~ "some updated <%= schema.string_attr %>"<% end %> end end end ================================================ FILE: priv/templates/phx.gen.live/show.ex.eex ================================================ defmodule <%= inspect context.web_module %>.<%= inspect Module.concat(schema.web_namespace, schema.alias) %>Live.Show do use <%= inspect context.web_module %>, :live_view alias <%= inspect context.module %> @impl true def render(assigns) do ~H""" <%= scope.assign_key %>={@<%= scope.assign_key %>}<% end %>> <.header> <%= schema.human_singular %> {@<%= schema.singular %>.<%= primary_key %>} <:subtitle>This is a <%= schema.singular %> record from your database. <:actions> <.button navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>"}> <.icon name="hero-arrow-left" /> <.button variant="primary" navigate={~p"<%= scope_assign_route_prefix %><%= schema.route_prefix %>/#{@<%= schema.singular %>}/edit?return_to=show"}> <.icon name="hero-pencil-square" /> Edit <%= schema.singular %> <.list><%= for {k, _} <- schema.attrs do %> <:item title="<%= Phoenix.Naming.humanize(Atom.to_string(k)) %>">{@<%= schema.singular %>.<%= k %>}<% end %> """ end @impl true def mount(%{"<%= primary_key %>" => <%= primary_key %>}, _session, socket) do<%= if scope do %> if connected?(socket) do <%= inspect context.alias %>.subscribe_<%= schema.plural %>(<%= socket_scope %>) end <% end %> {:ok, socket |> assign(:page_title, "Show <%= schema.human_singular %>") |> assign(:<%= schema.singular %>, <%= inspect context.alias %>.get_<%= schema.singular %>!(<%= context_scope_prefix %><%= primary_key %>))} end<%= if scope do %> @impl true def handle_info( {:updated, %<%= inspect schema.module %>{<%= primary_key %>: <%= primary_key %>} = <%= schema.singular %>}, %{assigns: %{<%= schema.singular %>: %{<%= primary_key %>: <%= primary_key %>}}} = socket ) do {:noreply, assign(socket, :<%= schema.singular %>, <%= schema.singular %>)} end def handle_info( {:deleted, %<%= inspect schema.module %>{<%= primary_key %>: <%= primary_key %>}}, %{assigns: %{<%= schema.singular %>: %{<%= primary_key %>: <%= primary_key %>}}} = socket ) do {:noreply, socket |> put_flash(:error, "The current <%= schema.singular %> was deleted.") |> push_navigate(to: ~p"<%= scope_socket_route_prefix %><%= schema.route_prefix %>")} end def handle_info({type, %<%= inspect schema.module %>{}}, socket) when type in [:created, :updated, :deleted] do {:noreply, socket} end<% end %> end ================================================ FILE: priv/templates/phx.gen.notifier/notifier.ex.eex ================================================ defmodule <%= inspect context.module %> do import Swoosh.Email alias <%= inspect context.base_module %>.Mailer<%= for message <- notifier_messages do %> def deliver_<%= message %>(%{name: name, email: email}) do new() |> to({name, email}) |> from({"Phoenix Team", "team@example.com"}) |> subject("Welcome to Phoenix, #{name}!") |> html_body("

Hello, #{name}

") |> text_body("Hello, #{name}\n") |> Mailer.deliver() end<% end %> end ================================================ FILE: priv/templates/phx.gen.notifier/notifier_test.exs.eex ================================================ defmodule <%= inspect context.module %>Test do use ExUnit.Case, async: true import Swoosh.TestAssertions alias <%= inspect context.module %><%= for message <- notifier_messages do %> test "deliver_<%= message %>/1" do user = %{name: "Alice", email: "alice@example.com"} <%= inflections[:alias] %>.deliver_<%= message %>(user) assert_email_sent( subject: "Welcome to Phoenix, Alice!", to: {"Alice", "alice@example.com"}, text_body: ~r/Hello, Alice/ ) end<% end %> end ================================================ FILE: priv/templates/phx.gen.presence/presence.ex.eex ================================================ defmodule <%= module %> do @moduledoc """ Provides presence tracking to channels and processes. See the [`Phoenix.Presence`](https://hexdocs.pm/phoenix/Phoenix.Presence.html) docs for more details. """ use Phoenix.Presence, otp_app: <%= inspect otp_app %>, pubsub_server: <%= inspect pubsub_server %> end ================================================ FILE: priv/templates/phx.gen.release/Dockerfile.eex ================================================ # Find eligible builder and runner images on Docker Hub. We use Ubuntu/Debian # instead of Alpine to avoid DNS resolution issues in production. # # https://hub.docker.com/r/hexpm/elixir/tags?name=ubuntu # https://hub.docker.com/_/ubuntu/tags # # This file is based on these images: # # - https://hub.docker.com/r/hexpm/elixir/tags - for the build image # - https://hub.docker.com/_/debian/tags?name=<%= debian %>-<%= debian_vsn %>-slim - for the release image # - https://pkgs.org/ - resource for finding needed packages # - Ex: docker.io/hexpm/elixir:<%= elixir_vsn %>-erlang-<%= otp_vsn %>-debian-<%= debian %>-<%= debian_vsn %>-slim # ARG ELIXIR_VERSION=<%= elixir_vsn %> ARG OTP_VERSION=<%= otp_vsn %> ARG DEBIAN_VERSION=<%= debian %>-<%= debian_vsn %>-slim ARG BUILDER_IMAGE="docker.io/hexpm/elixir:${ELIXIR_VERSION}-erlang-${OTP_VERSION}-debian-${DEBIAN_VERSION}" ARG RUNNER_IMAGE="docker.io/debian:${DEBIAN_VERSION}" FROM ${BUILDER_IMAGE} AS builder # install build dependencies RUN apt-get update \ && apt-get install -y --no-install-recommends build-essential git \ && rm -rf /var/lib/apt/lists/* # prepare build dir WORKDIR /app # install hex + rebar RUN mix local.hex --force \ && mix local.rebar --force # set build ENV ENV MIX_ENV="prod" # install mix dependencies COPY mix.exs mix.lock ./ RUN mix deps.get --only $MIX_ENV RUN mkdir config # copy compile-time config files before we compile dependencies # to ensure any relevant config change will trigger the dependencies # to be re-compiled. COPY config/config.exs config/${MIX_ENV}.exs config/ RUN mix deps.compile <%= if assets_dir_exists? do %> RUN mix assets.setup <% end %> COPY priv priv COPY lib lib # Compile the release RUN mix compile <%= if assets_dir_exists? do %> COPY assets assets # compile assets RUN mix assets.deploy <% end %> # Changes to config/runtime.exs don't require recompiling the code COPY config/runtime.exs config/ COPY rel rel RUN mix release # start a new build stage so that the final image will only contain # the compiled release and other runtime necessities FROM ${RUNNER_IMAGE} AS final RUN apt-get update \ && apt-get install -y --no-install-recommends libstdc++6 openssl libncurses6 locales ca-certificates \ && rm -rf /var/lib/apt/lists/* # Set the locale RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen \ && locale-gen ENV LANG=en_US.UTF-8 ENV LANGUAGE=en_US:en ENV LC_ALL=en_US.UTF-8 WORKDIR "/app" RUN chown nobody /app # set runner ENV ENV MIX_ENV="prod" # Only copy the final release from the build stage COPY --from=builder --chown=nobody:root /app/_build/${MIX_ENV}/rel/<%= otp_app %> ./ USER nobody # If using an environment that doesn't automatically reap zombie processes, it is # advised to add an init process such as tini via `apt-get install` # above and adding an entrypoint. See https://github.com/krallin/tini for details # ENTRYPOINT ["/tini", "--"] CMD ["/app/bin/server"] ================================================ FILE: priv/templates/phx.gen.release/dockerignore.eex ================================================ # This file excludes paths from the Docker build context. # # By default, Docker's build context includes all files (and folders) in the # current directory. Even if a file isn't copied into the container it is still sent to # the Docker daemon. # # There are multiple reasons to exclude files from the build context: # # 1. Prevent nested folders from being copied into the container (ex: exclude # /assets/node_modules when copying /assets) # 2. Reduce the size of the build context and improve build time (ex. /build, /deps, /doc) # 3. Avoid sending files containing sensitive information # # More information on using .dockerignore is available here: # https://docs.docker.com/engine/reference/builder/#dockerignore-file .dockerignore # Ignore git, but keep git HEAD and refs to access current commit hash if needed: # # $ cat .git/HEAD | awk '{print ".git/"$2}' | xargs cat # d0b8727759e1e0e7aa3d41707d12376e373d5ecc .git !.git/HEAD !.git/refs # Common development/test artifacts /cover/ /doc/ /test/ /tmp/ .elixir_ls # Mix artifacts /_build/ /deps/ *.ez # Generated on crash by the VM erl_crash.dump # Static artifacts - These should be fetched and built inside the Docker image # https://hexdocs.pm/phoenix/Mix.Tasks.Phx.Gen.Release.html#module-docker /assets/node_modules/ /priv/static/assets/ /priv/static/cache_manifest.json ================================================ FILE: priv/templates/phx.gen.release/rel/migrate.bat.eex ================================================ call "%~dp0\<%= otp_app %>" eval <%= app_namespace %>.Release.migrate ================================================ FILE: priv/templates/phx.gen.release/rel/migrate.sh.eex ================================================ #!/bin/sh set -eu cd -P -- "$(dirname -- "$0")" exec ./<%= otp_app %> eval <%= app_namespace %>.Release.migrate ================================================ FILE: priv/templates/phx.gen.release/rel/server.bat.eex ================================================ set PHX_SERVER=true call "%~dp0\<%= otp_app %>" start ================================================ FILE: priv/templates/phx.gen.release/rel/server.sh.eex ================================================ #!/bin/sh set -eu cd -P -- "$(dirname -- "$0")" PHX_SERVER=true exec ./<%= otp_app %> start ================================================ FILE: priv/templates/phx.gen.release/release.ex.eex ================================================ defmodule <%= app_namespace %>.Release do @moduledoc """ Used for executing DB release tasks when run in production without Mix installed. """ @app :<%= otp_app %> def migrate do load_app() for repo <- repos() do {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true)) end end def rollback(repo, version) do load_app() {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version)) end defp repos do Application.fetch_env!(@app, :ecto_repos) end defp load_app do # Many platforms require SSL when connecting to the database Application.ensure_all_started(:ssl) Application.ensure_loaded(@app) end end ================================================ FILE: priv/templates/phx.gen.schema/migration.exs.eex ================================================ defmodule <%= inspect schema.repo %>.Migrations.Create<%= Macro.camelize(schema.table) %> do use <%= inspect schema.migration_module %> def change do create table(:<%= schema.table %><%= if schema.binary_id || schema.opts[:primary_key] do %>, primary_key: false<% end %><%= if schema.prefix do %>, prefix: :<%= schema.prefix %><% end %>) do <%= if schema.binary_id do %> add :<%= primary_key %>, :binary_id, primary_key: true <% else %><%= if schema.opts[:primary_key] do %> add :<%= schema.opts[:primary_key] %>, :id, primary_key: true <% end %><% end %><%= for {k, v} <- schema.attrs do %> add <%= inspect k %>, <%= inspect Mix.Phoenix.Schema.type_for_migration(v) %><%= schema.migration_defaults[k] %> <% end %><%= for {_, i, _, s} <- schema.assocs do %> add <%= inspect(i) %>, references(<%= inspect(s) %>, on_delete: :nothing<%= if schema.binary_id do %>, type: :binary_id<% end %>) <% end %><%= if scope do %> add :<%= scope.schema_key %>, <%= if scope.schema_table do %>references(:<%= scope.schema_table %>, type: <%= inspect scope.schema_migration_type %>, on_delete: :delete_all)<% else %><%= inspect scope.schema_migration_type %><% end %> <% end %> timestamps(<%= if schema.timestamp_type != :naive_datetime, do: "type: #{inspect schema.timestamp_type}" %>) end<%= if scope do %> create index(:<%= schema.table %>, [:<%= scope.schema_key %>])<% end %> <%= if Enum.any?(schema.indexes) do %><%= for index <- schema.indexes do %> <%= index %><% end %> <% end %> end end ================================================ FILE: priv/templates/phx.gen.schema/schema.ex.eex ================================================ defmodule <%= inspect schema.module %> do use Ecto.Schema import Ecto.Changeset <%= if schema.prefix do %> @schema_prefix :<%= schema.prefix %><% end %><%= if schema.opts[:primary_key] do %> @derive {Phoenix.Param, key: :<%= schema.opts[:primary_key] %>}<% end %><%= if schema.binary_id do %> @primary_key {:<%= primary_key %>, :binary_id, autogenerate: true} @foreign_key_type :binary_id<% else %><%= if schema.opts[:primary_key] do %> @primary_key {:<%= schema.opts[:primary_key] %>, :id, autogenerate: true}<% end %><% end %> schema <%= inspect schema.table %> do <%= Mix.Phoenix.Schema.format_fields_for_schema(schema) %> <%= for {_, k, _, _} <- schema.assocs do %> field <%= inspect k %>, <%= if schema.binary_id do %>:binary_id<% else %>:id<% end %> <% end %><%= if scope do %> field :<%= scope.schema_key %>, <%= inspect scope.schema_type %> <% end %> timestamps(<%= if schema.timestamp_type != :naive_datetime, do: "type: #{inspect schema.timestamp_type}" %>) end @doc false def changeset(<%= schema.singular %>, attrs<%= if scope do %>, <%= scope.name %>_scope<% end %>) do <%= schema.singular %> |> cast(attrs, [<%= Enum.map_join(schema.attrs, ", ", &inspect(elem(&1, 0))) %>]) |> validate_required([<%= Enum.map_join(Mix.Phoenix.Schema.required_fields(schema), ", ", &inspect(elem(&1, 0))) %>]) <%= for k <- schema.uniques do %> |> unique_constraint(<%= inspect k %>) <% end %><%= if scope do %> |> put_change(:<%= scope.schema_key %>, <%= scope.name %>_scope.<%= Enum.join(scope.access_path, ".") %>) <% end %> end end ================================================ FILE: priv/templates/phx.gen.socket/socket.ex.eex ================================================ defmodule <%= module %>Socket do use Phoenix.Socket # A Socket handler # # It's possible to control the websocket connection and # assign values that can be accessed by your channel topics. ## Channels<%= if existing_channel do %> channel "<%= existing_channel[:singular] %>:*", <%= existing_channel[:module] %>Channel <% else %> # Uncomment the following line to define a "room:*" topic # pointing to the `<%= web_module %>.RoomChannel`: # # channel "room:*", <%= web_module %>.RoomChannel # # To create a channel file, use the mix task: # # mix phx.gen.channel Room # # See the [`Channels guide`](https://hexdocs.pm/phoenix/channels.html) # for further details. <% end %> # Socket params are passed from the client and can # be used to verify and authenticate a user. After # verification, you can put default assigns into # the socket that will be set for all channels, ie # # {:ok, assign(socket, :user_id, verified_user_id)} # # To deny connection, return `:error` or `{:error, term}`. To control the # response the client receives in that case, [define an error handler in the # websocket # configuration](https://hexdocs.pm/phoenix/Phoenix.Endpoint.html#socket/3-websocket-configuration). # # See `Phoenix.Token` documentation for examples in # performing token verification on connect. @impl true def connect(_params, socket, _connect_info) do {:ok, socket} end # Socket IDs are topics that allow you to identify all sockets for a given user: # # def id(socket), do: "user_socket:#{socket.assigns.user_id}" # # Would allow you to broadcast a "disconnect" event and terminate # all active sockets and channels for a given user: # # <%= endpoint_module %>.broadcast("user_socket:#{user.id}", "disconnect", %{}) # # Returning `nil` makes this socket anonymous. @impl true def id(_socket), do: nil end ================================================ FILE: priv/templates/phx.gen.socket/socket.js.eex ================================================ // NOTE: The contents of this file will only be executed if // you uncomment its entry in "assets/js/app.js". // Bring in Phoenix channels client library: import {Socket} from "phoenix" // And connect to the path in "<%= web_prefix %>/endpoint.ex". We pass the // token for authentication. // // Read the [`Using Token Authentication`](https://hexdocs.pm/phoenix/channels.html#using-token-authentication) // section to see how the token should be used. let socket = new Socket("/socket", {authToken: window.userToken}) socket.connect() // Now that you are connected, you can join channels with a topic. // Let's assume you have a channel with a topic named `room` and the // subtopic is its id - in this case 42: let channel = socket.channel("room:42", {}) channel.join() .receive("ok", resp => { console.log("Joined successfully", resp) }) .receive("error", resp => { console.log("Unable to join", resp) }) export default socket ================================================ FILE: test/fixtures/digest/cleaner/cache_manifest.json ================================================ { "digests": { "app-1.css": { "logical_path": "app.css", "mtime": 32132171, "size": 369053, "digest": "1" }, "app-2.css": { "logical_path": "app.css", "mtime": 32132172, "size": 369053, "digest": "2" }, "app-3.css": { "logical_path": "app.css", "mtime": 32132173, "size": 369053, "digest": "3" } }, "latest": { "app.css": "app-3.css" }, "version": 1 } ================================================ FILE: test/fixtures/digest/cleaner/latest_not_most_recent_cache_manifest.json ================================================ { "digests": { "app-1.css": { "logical_path": "app.css", "mtime": 32132171, "size": 369053, "digest": "1" }, "app-2.css": { "logical_path": "app.css", "mtime": 32132172, "size": 369053, "digest": "2" }, "app-3.css": { "logical_path": "app.css", "mtime": 32132170, "size": 369053, "digest": "3" } }, "latest": { "app.css": "app-3.css" }, "version": 1 } ================================================ FILE: test/fixtures/digest/compile/cache_manifest.json ================================================ { "digests": { "foo-d978852bea6530fcd197b5445ed008fd.css": { "logical_path": "foo.css", "mtime": 32132171, "size": 369053, "digest": "d978852bea6530fcd197b5445ed008fd" } }, "latest": { "foo.css": "foo-d978852bea6530fcd197b5445ed008fd.css" }, "version": 1 } ================================================ FILE: test/fixtures/digest/compile/cache_manifest_upgrade.json ================================================ { "digests": { "foo-abcdef.css": { "logical_path": "foo.css", "mtime": 32132171, "size": 369053, "digest": "abcdev" }, "foo-ghijkl.css": { "logical_path": "foo.css", "mtime": 32193492, "size": 372059, "digest": "abcdev" } }, "latest": { "foo.css": "foo-ghijkl.css" }, "version": 1 } ================================================ FILE: test/fixtures/digest/priv/output/foo-288ea8c7954498e65663c817382eeac4.css ================================================ .foo { background-color: blue } ================================================ FILE: test/fixtures/digest/priv/output/foo-d978852bea6530fcd197b5445ed008fd.css ================================================ .foo { background-color: red } ================================================ FILE: test/fixtures/digest/priv/static/app.js ================================================ (function() { console.log('Hello World!'); })(); //# sourceMappingURL=app.js.map ================================================ FILE: test/fixtures/digest/priv/static/css/app.css ================================================ .absolute_path_logo { background-image: url("/phoenix.png"); } .relative_path_logo { background-image: url('../images/relative.png'); } .absolute_url_logo { background-image: url(http://www.phoenixframework.org/absolute.png); } .absolute_path_logo{background-image:url(/phoenix.png)} .relative_path_logo{background-image:url(../images/relative.png)} .absolute_url_logo{background-image:url(http://www.phoenixframework.org/absolute.png)} ================================================ FILE: test/fixtures/digest/priv/static/foo.css ================================================ .foo { background-color: red } ================================================ FILE: test/fixtures/digest/priv/static/manifest.json ================================================ { "name": "MyPhoenixApp", "short_name": "MyPhoenixApp", "start_url": ".", "display": "standalone", "background_color": "#F67938", "description": "A simple Phoenix app.", "icons": [{ "src": "images/touch/homescreen48.png", "sizes": "48x48", "type": "image/png" }, { "src": "images/touch/homescreen72.png", "sizes": "72x72", "type": "image/png" }, { "src": "images/touch/homescreen96.png", "sizes": "96x96", "type": "image/png" }, { "src": "images/touch/homescreen144.png", "sizes": "144x144", "type": "image/png" }, { "src": "images/touch/homescreen168.png", "sizes": "168x168", "type": "image/png" }, { "src": "images/touch/homescreen192.png", "sizes": "192x192", "type": "image/png" }] } ================================================ FILE: test/fixtures/digest/priv/static/precompressed.js.br ================================================ Brotli ================================================ FILE: test/fixtures/hello.txt ================================================ world ================================================ FILE: test/fixtures/ssl/cert.pem ================================================ -----BEGIN CERTIFICATE----- MIIEwTCCA6mgAwIBAgIJAJmNQmFFDZgVMA0GCSqGSIb3DQEBBQUAMIGbMQswCQYD VQQGEwJVUzENMAsGA1UECBMET2hpbzEPMA0GA1UEBxMGRGF5dG9uMRowGAYDVQQK ExFQaG9lbml4IEZyYW1ld29yazEaMBgGA1UECxMRU3lzdGVtIEFyY2hpdGVjdHMx EjAQBgNVBAMTCWxvY2FsaG9zdDEgMB4GCSqGSIb3DQEJARYRcGhvZW5peEBsb2Nh bGhvc3QwHhcNMTQwNTI1MDAxNTM5WhcNMTUwNTI1MDAxNTM5WjCBmzELMAkGA1UE BhMCVVMxDTALBgNVBAgTBE9oaW8xDzANBgNVBAcTBkRheXRvbjEaMBgGA1UEChMR UGhvZW5peCBGcmFtZXdvcmsxGjAYBgNVBAsTEVN5c3RlbSBBcmNoaXRlY3RzMRIw EAYDVQQDEwlsb2NhbGhvc3QxIDAeBgkqhkiG9w0BCQEWEXBob2VuaXhAbG9jYWxo b3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0g3Mlh7ZRYiE+btN bePpRGzdj4NIyleZj5LXxRe8xZs/WHb4j1+UfUxRrAO141UYcE1ZXkpg8x64uUiR m281JPvHGe8CqZlckZQGVF77Bv8oH6gGTxyrI7Gdni2CJgMqR9A4Kwdlczk7d+fV vQCl8B5izEmCTXWu8RG/QU1BHQLygT/DSHgeGjzQaaE0OoD/Hxa/zkVPEugjNtxF YVWGQ0gzqsTPFz1CkIp1+CJHzm/fhFtFaS0aDeFyMW1BRC8CTYXyYdcM9cSn/ahh gmKhYKY3EbRaiE4dfH2rqzvixc+OOEQVpMPDCVDG0ms/FhCrLzVBoY4/WiZVv6aq 2jznmwIDAQABo4IBBDCCAQAwHQYDVR0OBBYEFPQA6slwgMEFuEbYd+lG4WICZb1u MIHQBgNVHSMEgcgwgcWAFPQA6slwgMEFuEbYd+lG4WICZb1uoYGhpIGeMIGbMQsw CQYDVQQGEwJVUzENMAsGA1UECBMET2hpbzEPMA0GA1UEBxMGRGF5dG9uMRowGAYD VQQKExFQaG9lbml4IEZyYW1ld29yazEaMBgGA1UECxMRU3lzdGVtIEFyY2hpdGVj dHMxEjAQBgNVBAMTCWxvY2FsaG9zdDEgMB4GCSqGSIb3DQEJARYRcGhvZW5peEBs b2NhbGhvc3SCCQCZjUJhRQ2YFTAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUA A4IBAQAZkmKd/KPN3FXsgYU+2iNKHAdzByEugGbTSdba5WBAwwJCumhGUy8CFXY6 MhfrQjj7mkkU4UFHkHXZCWbucfTGxWFaizkkaStsY+5K6sKVFQZw8kc5llDD4dyG JNGX99VYtVvJG/GS/rXiOTHJvR4WYbgJ5DPYI+PVWBVIp5wG9T2G8TinTnguFGC6 /EFmYf06XGUAKWsMfzNm8Dm7fkQ94W27FVtJ9RvdeObi2aJt37bE9DVqUkjZ1qtz fz3uJ5UyoNFn5tCBOdEooivPlvl4wqSTppIpflMNlE82KhSRnESnZF9JQUGW3Lnd 2H3UOAYVUDhGVP/J9ZJLTcr8O8zA -----END CERTIFICATE----- ================================================ FILE: test/fixtures/ssl/key.pem ================================================ -----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEA0g3Mlh7ZRYiE+btNbePpRGzdj4NIyleZj5LXxRe8xZs/WHb4 j1+UfUxRrAO141UYcE1ZXkpg8x64uUiRm281JPvHGe8CqZlckZQGVF77Bv8oH6gG TxyrI7Gdni2CJgMqR9A4Kwdlczk7d+fVvQCl8B5izEmCTXWu8RG/QU1BHQLygT/D SHgeGjzQaaE0OoD/Hxa/zkVPEugjNtxFYVWGQ0gzqsTPFz1CkIp1+CJHzm/fhFtF aS0aDeFyMW1BRC8CTYXyYdcM9cSn/ahhgmKhYKY3EbRaiE4dfH2rqzvixc+OOEQV pMPDCVDG0ms/FhCrLzVBoY4/WiZVv6aq2jznmwIDAQABAoIBAFhR/QfSCME32dG3 c6MVBWwD6lUBeoW5t5OqxpbUmEbuNABaZcDDC4hzopOVK9FeYlw16bG/zGvtKvad ELwuUkYup1S8Ln5pQYbkmpS3Kw2SE6jb2WtCPqNPd1qe/+5Dvm9bmYJeJcYA9oRA Mpq5vwvretcywVsYdGpgb+5hMVOkunw25I4eNeqZHX1ZKmcgq4I/UcZzoF2qPUC6 jtU4reZn8yTgki0YRJVKvw2QLKTegVbK0JHhHDQBxHyfaoj+gd1abZHHMcG0k82k Hr86xOJYVGcmZeKk9P/VIPCASgfAbIR23lFkyTxH+GGcrUQvn/kvruKvpQqXgDRo pz+0IUECgYEA79u2t6SNjZf9z01ZZdWvI0q4q5/v/uuIx05NCbpugJh9XVCoJ88T jLf7Ul8EKFj9i4CG9HlrtFkIwgKoJGiiIOdUD0vNwSgFEwht8KnbxHASsqo8UU1x bjgKBPKz3c2hJu4iXQikjHD+wAl2m7X+K0Z62gcY2IKdFI67RpsxwWMCgYEA4DCd cIWtznK40PboyeUIYtgrNKSaS1kbQOb2nj3HhJ3X3cbFvk5Yl28ac4cjmidXvN7Q 3bthZFI0ItagLs1raMbiX4kKo2ISeS2jkJZK2PQFWh7Brc4Q+RktTIRFoHyP35uO dvHJH+rEz0oURbjqSlDbB/eFysiOK8mRUTd38mkCgYARWu5/nzJ22laNF2WujqWb gh6WnH37DgPZl/rPB2RTfbUkeV+RcdRSTEWtEh705GuEGoqpSdfXNtIBZ7vO1ptU kihs6uk6XrDvTZ7W2RODxTA1KUgwAdCBTyC6du040VYlwPlPjf6KAusL7iNc5PA9 JV5iRD0x/VFsWV+HnlcdTQKBgQDPn3ZPPR4n8csDi4cvYzMPB4+L410Zpt48jyma hzB9uwit1WZQxpH5POXMVD0+iG0S92+Lyft6Qz8RfJ9AePGeSYJgY7Q8d5kQLJos T2Pl5KgIPC+2XP8PEqgHEwDAjltYBOI9edKAApZeOwbnQ0eHp7YRfMSldnNkTfqM ssgc8QKBgDflG6bfSrjOjgyppsII4tXKdpnRa/UwN98D3/ZU5VJA8jR8yzHuMico bpeooh03uH8xLalXlXNRAamSv03KprvXRXeA+GeAeoseB1qHJ7Z2pkkqiHFG2XxY u0jAsKamaT6YjcLqloxOdPSyDoXon6pKxvSsiUg1l9ZASexuTiZV -----END RSA PRIVATE KEY----- ================================================ FILE: test/fixtures/templates/custom.foo ================================================ from foo ================================================ FILE: test/fixtures/templates/layout/app.html.eex ================================================ <%= @title || default_title() %> <%= @inner_content %> ================================================ FILE: test/fixtures/templates/layout/root.html.eex ================================================ ROOTSTART[<%= @title %>]<%= @inner_content %>ROOTEND ================================================ FILE: test/fixtures/templates/no_trim.text.eex ================================================ <%= 123 %> <%= 456 %> <%= 789 %> ================================================ FILE: test/fixtures/templates/path.html.eex ================================================ path ================================================ FILE: test/fixtures/templates/safe.html.eex ================================================ Raw <%= {:safe, @message} %> ================================================ FILE: test/fixtures/templates/show.html.eex ================================================
Show! <%= @message %>
<% :ok # Template is still valid %> ================================================ FILE: test/fixtures/templates/trim.html.eex ================================================ <%= 123 %> <%= 456 %> <%= 789 %> ================================================ FILE: test/fixtures/templates/user/index.html.eex ================================================ <%= escaped_title @title %> ================================================ FILE: test/fixtures/templates/user/profiles/admin.html.eex ================================================ admin profile ================================================ FILE: test/fixtures/templates/user/render_template.html.eex ================================================ rendered template for <%= @name %> ================================================ FILE: test/fixtures/templates/user/show.json.exs ================================================ %{foo: "bar"} ================================================ FILE: test/fixtures/views.exs ================================================ defmodule MyApp.View do use Phoenix.View, root: "test/fixtures/templates" def escaped_title(title) do {:safe, Plug.HTML.html_escape(title)} end end defmodule MyApp.LayoutView do use Phoenix.View, root: "test/fixtures/templates" def default_title do "MyApp" end end defmodule MyApp.User do defstruct name: "name" end defmodule MyApp.PathView do use Phoenix.View, root: "test/fixtures/templates", path: "" end defmodule MyApp.UserView do use Phoenix.View, root: "test/fixtures/templates", pattern: "**/*" import Phoenix.Controller, only: [view_module: 1, view_template: 1] def escaped_title(title) do {:safe, Plug.HTML.html_escape(title)} end def render("message.html", _assigns) do send(self(), :message_sent) "message sent" end def render("show.text", %{user: user, prefix: prefix}) do "show user: " <> prefix <> user.name end def render("show.text", %{user: user}) do "show user: " <> user.name end def render("data.text", %{data: data}) do "show data: " <> data.name end def render("edit.html", %{} = assigns) do "EDIT#{assigns[:layout]} - #{assigns[:title]}" end def render("existing.html", _), do: "rendered existing" def render("inner.html", assigns) do """ View module is #{view_module(assigns.conn)} and view template is #{view_template(assigns.conn)} """ end def render("render_template.html" = tpl, %{name: name}) do render_template(tpl, %{name: String.upcase(name)}) end def render("to_iodata.html", %{to_iodata: to_iodata}) do to_iodata end end defmodule MyApp.Templates.UserView do use Phoenix.View, root: "test/fixtures" def escaped_title(title) do {:safe, Plug.HTML.html_escape(title)} end end defmodule MyApp.Nested.User do defstruct name: "nested name" end defmodule MyApp.Nested.UserView do use Phoenix.View, root: "test/fixtures/templates", namespace: MyApp.Nested def render("show.text", %{user: user}) do "show nested user: " <> user.name end def escaped_title(title) do {:safe, Plug.HTML.html_escape(title)} end end ================================================ FILE: test/mix/phoenix_test.exs ================================================ defmodule Mix.PhoenixTest do use ExUnit.Case, async: true doctest Mix.Phoenix, import: true test "base/0 returns the module base based on the Mix application" do assert Mix.Phoenix.base() == "Phoenix" Application.put_env(:phoenix, :namespace, Phoenix.Sample.App) assert Mix.Phoenix.base() == "Phoenix.Sample.App" after Application.delete_env(:phoenix, :namespace) end test "modules/0 returns all modules in project" do assert Phoenix.Router in Mix.Phoenix.modules() end test "attrs/1 defaults each type" do attrs = [ "logins:array:string", "lottery_numbers:array:integer", "age:integer", "temp:float", "temp_2:decimal", "admin:boolean", "meta:map", "name:text", "date_of_birth:date", "happy_hour:time", "joined:naive_datetime", "token:uuid" ] assert Mix.Phoenix.Schema.attrs(attrs) == [ logins: {:array, :string}, lottery_numbers: {:array, :integer}, age: :integer, temp: :float, temp_2: :decimal, admin: :boolean, meta: :map, name: :text, date_of_birth: :date, happy_hour: :time, joined: :naive_datetime, token: :uuid ] end test "attrs/1 raises with an unknown type" do assert_raise(Mix.Error, ~r"Unknown type `:other` given to generator", fn -> Mix.Phoenix.Schema.attrs(["other:other"]) end) end test "params/1 defaults each type" do params = [ logins: {:array, :string}, age: :integer, temp: :float, temp_2: :decimal, admin: :boolean, meta: :map, name: :text, date_of_birth: :date, happy_hour: :time, happy_hour_usec: :time_usec, joined: :naive_datetime, joined_utc: :utc_datetime, joined_utc_usec: :utc_datetime_usec, token: :uuid, other: :other ] assert Mix.Phoenix.Schema.params(params) == %{ logins: ["option1", "option2"], age: 42, temp: 120.5, temp_2: "120.5", admin: true, meta: %{}, name: "some name", date_of_birth: Date.add(Date.utc_today(), -1), happy_hour: ~T[14:00:00], happy_hour_usec: ~T[14:00:00.000000], joined: NaiveDateTime.truncate(build_utc_naive_datetime(), :second), joined_utc: DateTime.truncate(build_utc_datetime(), :second), joined_utc_usec: build_utc_datetime(), token: "7488a646-e31f-11e4-aace-600308960662", other: "some other" } end @one_day_in_seconds 24 * 3600 defp build_utc_datetime, do: DateTime.add(%{DateTime.utc_now() | second: 0, microsecond: {0, 6}}, -@one_day_in_seconds) defp build_utc_naive_datetime, do: NaiveDateTime.add( %{NaiveDateTime.utc_now() | second: 0, microsecond: {0, 6}}, -@one_day_in_seconds ) test "live_form_value/1" do assert Mix.Phoenix.Schema.live_form_value(~D[2020-10-09]) == "2020-10-09" assert Mix.Phoenix.Schema.live_form_value(~T[14:00:00]) == "14:00" assert Mix.Phoenix.Schema.live_form_value(~T[14:01:00]) == "14:01" assert Mix.Phoenix.Schema.live_form_value(~T[14:15:40]) == "14:15" assert Mix.Phoenix.Schema.live_form_value(~N[2020-10-09 14:00:00]) == "2020-10-09T14:00:00" assert Mix.Phoenix.Schema.live_form_value(~U[2020-10-09T14:00:00Z]) == "2020-10-09T14:00:00Z" assert Mix.Phoenix.Schema.live_form_value([1]) == [1] assert Mix.Phoenix.Schema.live_form_value(["option1"]) == ["option1"] assert Mix.Phoenix.Schema.live_form_value(:value) == :value end test "invalid_form_value/1" do assert ~D[2020-10-09] |> Mix.Phoenix.Schema.invalid_form_value() == "2022-00" assert ~T[14:00:00] |> Mix.Phoenix.Schema.invalid_form_value() == %{hour: 14, minute: 00} assert ~N[2020-10-09 14:00:00] |> Mix.Phoenix.Schema.invalid_form_value() == "2022-00" assert ~U[2020-10-09T14:00:00Z] |> Mix.Phoenix.Schema.invalid_form_value() == "2022-00" assert Mix.Phoenix.Schema.invalid_form_value(true) == false assert Mix.Phoenix.Schema.invalid_form_value(:anything) == nil end end ================================================ FILE: test/mix/tasks/phx.digest.clean_test.exs ================================================ defmodule Mix.Tasks.Phx.Digest.CleanTest do use ExUnit.Case test "fails when the given paths are invalid" do Mix.Tasks.Phx.Digest.Clean.run(["--output", "invalid_path", "--no-compile"]) assert_received {:mix_shell, :error, ["The output path \"invalid_path\" does not exist"]} end test "removes old versions", config do output_path = Path.join("tmp", to_string(config.test)) input_path = "priv/static" try do :ok = File.mkdir_p!(output_path) Mix.Tasks.Phx.Digest.Clean.run([input_path, "-o", output_path, "--no-compile"]) msg = "Clean complete for \"#{output_path}\"" assert_received {:mix_shell, :info, [^msg]} after File.rm_rf!(output_path) end end end ================================================ FILE: test/mix/tasks/phx.digest_test.exs ================================================ Code.require_file "../../../installer/test/mix_helper.exs", __DIR__ defmodule Mix.Tasks.Phx.DigestTest do use ExUnit.Case import MixHelper test "logs when the path is invalid" do Mix.Tasks.Phx.Digest.run(["invalid_path", "--no-compile"]) assert_received {:mix_shell, :error, ["The input path \"invalid_path\" does not exist"]} end @output_path "mix_phoenix_digest" test "digests and compress files" do in_tmp @output_path, fn -> File.mkdir_p!("priv/static") Mix.Tasks.Phx.Digest.run(["priv/static", "-o", @output_path, "--no-compile"]) assert_received {:mix_shell, :info, ["Check your digested files at \"mix_phoenix_digest\""]} end end @output_path "mix_phoenix_digest_no_input" test "digests and compress files without the input path" do in_tmp @output_path, fn -> File.mkdir_p!("priv/static") Mix.Tasks.Phx.Digest.run(["-o", @output_path, "--no-compile"]) assert_received {:mix_shell, :info, ["Check your digested files at \"mix_phoenix_digest_no_input\""]} end end @input_path "input_path" test "uses the input path as output path when no output path is given" do in_tmp @input_path, fn -> File.mkdir_p!(@input_path) Mix.Tasks.Phx.Digest.run([@input_path, "--no-compile"]) assert_received {:mix_shell, :info, ["Check your digested files at \"input_path\""]} end end end ================================================ FILE: test/mix/tasks/phx.gen.auth/injector_test.exs ================================================ defmodule Mix.Tasks.Phx.Gen.Auth.InjectorTest do use ExUnit.Case, async: true alias Mix.Phoenix.{Context, Schema} alias Mix.Tasks.Phx.Gen.Auth.{HashingLibrary, Injector} describe "mix_dependency_inject/2" do test "injects before existing dependencies" do existing_file = """ defmodule RainyDay.MixProject do use Mix.Project def project do [ app: :rainy_day, version: "0.1.0", build_path: "../../_build", config_path: "../../config/config.exs", deps_path: "../../deps", lockfile: "../../mix.lock", elixir: "~> 1.7", elixirc_paths: elixirc_paths(Mix.env()), start_permanent: Mix.env() == :prod, aliases: aliases(), deps: deps() ] end # Configuration for the OTP application. # # Type `mix help compile.app` for more information. def application do [ mod: {RainyDay.Application, []}, extra_applications: [:logger, :runtime_tools] ] 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_pubsub, "~> 2.0-dev", github: "phoenixframework/phoenix_pubsub"}, {:ecto_sql, "~> 3.10"}, {:postgrex, ">= 0.0.0"}, {:jason, "~> 1.0"} ] end # Aliases are shortcuts or tasks specific to the current project. # For example, to create, migrate and run the seeds file at once: # # $ mix ecto.setup # # See the documentation for `Mix` for more info on aliases. defp aliases do [ "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"], "ecto.reset": ["ecto.drop", "ecto.setup"], test: ["ecto.create --quiet", "ecto.migrate", "test"] ] end end """ inject = ~s|{:bcrypt_elixir, "~> 2.0"}| assert {:ok, new_file} = Injector.mix_dependency_inject(existing_file, inject) assert new_file == """ defmodule RainyDay.MixProject do use Mix.Project def project do [ app: :rainy_day, version: "0.1.0", build_path: "../../_build", config_path: "../../config/config.exs", deps_path: "../../deps", lockfile: "../../mix.lock", elixir: "~> 1.7", elixirc_paths: elixirc_paths(Mix.env()), start_permanent: Mix.env() == :prod, aliases: aliases(), deps: deps() ] end # Configuration for the OTP application. # # Type `mix help compile.app` for more information. def application do [ mod: {RainyDay.Application, []}, extra_applications: [:logger, :runtime_tools] ] 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 [ {:bcrypt_elixir, "~> 2.0"}, {:phoenix_pubsub, "~> 2.0-dev", github: "phoenixframework/phoenix_pubsub"}, {:ecto_sql, "~> 3.10"}, {:postgrex, ">= 0.0.0"}, {:jason, "~> 1.0"} ] end # Aliases are shortcuts or tasks specific to the current project. # For example, to create, migrate and run the seeds file at once: # # $ mix ecto.setup # # See the documentation for `Mix` for more info on aliases. defp aliases do [ "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"], "ecto.reset": ["ecto.drop", "ecto.setup"], test: ["ecto.create --quiet", "ecto.migrate", "test"] ] end end """ end test "when injected dependency already exists" do existing_file = """ defmodule MyApp.MixFile do defp deps do [ {:bcrypt_elixir, "~> 2.0"}, {:ecto_sql, "~> 2.0"} ] end end """ inject = ~s|{:bcrypt_elixir, "~> 2.0"}| assert :already_injected = Injector.mix_dependency_inject(existing_file, inject) end test "when unable to automatically inject" do existing_file = """ defmodule MyApp.MixFile do end """ inject = ~s|{:bcrypt_elixir, "~> 2.0"}| assert {:error, :unable_to_inject} = Injector.mix_dependency_inject(existing_file, inject) end end describe "inject_before_final_end/2" do test "injects code when not previously injected" do existing_code = """ defmodule MyApp.Router do use MyApp, :router end """ code_to_inject = """ scope "/", MyApp do resources "/companies", CompanyController end """ assert {:ok, new_code} = Injector.inject_before_final_end(existing_code, code_to_inject) assert new_code == """ defmodule MyApp.Router do use MyApp, :router scope "/", MyApp do resources "/companies", CompanyController end end """ end test "returns :already_injected when code has been injected" do existing_code = """ defmodule MyApp.Router do use MyApp, :router scope "/", MyApp do resources "/companies", CompanyController end end """ code_to_inject = """ scope "/", MyApp do resources "/companies", CompanyController end """ assert :already_injected = Injector.inject_before_final_end(existing_code, code_to_inject) end end describe "inject_unless_contains/3" do test "injects when code doesn't already contain code_to_inject" do existing_code = """

My App

""" code_to_inject = ~s|<.user_menu current_user={@current_user} />| assert {:ok, new_code} = Injector.inject_unless_contains( existing_code, code_to_inject, &String.replace(&1, "", "\n #{&2}") ) assert new_code == """ <.user_menu current_user={@current_user} />

My App

""" end test "returns :already_injected when the existing code already contains code_to_inject" do existing_code = """

My App

""" code_to_inject = ~s|<.user_menu current_user={@current_user} />| assert :already_injected = Injector.inject_unless_contains( existing_code, code_to_inject, &String.replace(&1, "", "\n #{&2}") ) end test "returns {:error, :unable_to_inject} when no change is made" do existing_code = "" code_to_inject = ~s|<.user_menu current_user={@current_user} />| assert {:error, :unable_to_inject} = Injector.inject_unless_contains( existing_code, code_to_inject, &String.replace(&1, "", "\n #{&2}") ) end end describe "test_config_inject/2" do test "injects after \"use Mix.Config\" when hashing_library is bcrypt" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") input = """ use Mix.Config """ {:ok, injected} = Injector.test_config_inject(input, hashing_library) assert injected == """ use Mix.Config # Only in tests, remove the complexity from the password hashing algorithm config :bcrypt_elixir, :log_rounds, 1 """ end test "injects after \"use Mix.Config\" when hashing_library is pbkdf2" do {:ok, hashing_library} = HashingLibrary.build("pbkdf2") input = """ use Mix.Config """ {:ok, injected} = Injector.test_config_inject(input, hashing_library) assert injected == """ use Mix.Config # Only in tests, remove the complexity from the password hashing algorithm config :pbkdf2_elixir, :rounds, 1 """ end test "injects after \"use Mix.Config\" when hashing_library is argon2" do {:ok, hashing_library} = HashingLibrary.build("argon2") input = """ use Mix.Config """ {:ok, injected} = Injector.test_config_inject(input, hashing_library) assert injected == """ use Mix.Config # Only in tests, remove the complexity from the password hashing algorithm config :argon2_elixir, t_cost: 1, m_cost: 8 """ end test "injects after \"use Mix.Config\" when there is existing content" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") input = """ use Mix.Config # Print only warnings and errors during test config :logger, level: :warning """ {:ok, injected} = Injector.test_config_inject(input, hashing_library) assert injected == """ use Mix.Config # Only in tests, remove the complexity from the password hashing algorithm config :bcrypt_elixir, :log_rounds, 1 # Print only warnings and errors during test config :logger, level: :warning """ end test "injects after \"import Config\" when there is existing content" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") input = """ import Config # Print only warnings and errors during test config :logger, level: :warning """ {:ok, injected} = Injector.test_config_inject(input, hashing_library) assert injected == """ import Config # Only in tests, remove the complexity from the password hashing algorithm config :bcrypt_elixir, :log_rounds, 1 # Print only warnings and errors during test config :logger, level: :warning """ end test "injects when there are windows line endings" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") input = """ import Config\r \r # Print only warnings and errors during test\r config :logger, level: :warning\r """ {:ok, injected} = Injector.test_config_inject(input, hashing_library) assert injected == """ import Config\r \r # Only in tests, remove the complexity from the password hashing algorithm\r config :bcrypt_elixir, :log_rounds, 1\r \r # Print only warnings and errors during test\r config :logger, level: :warning\r """ end test "returns :already_injected when config is already found in file" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") input = """ import Config # Print only warnings and errors during test config :logger, level: :warning # Only in tests, remove the complexity from the password hashing algorithm config :bcrypt_elixir, :log_rounds, 1 """ assert :already_injected = Injector.test_config_inject(input, hashing_library) end test "returns :already_injected when config is already found when using windows line endings" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") input = """ import Config\r \r # Print only warnings and errors during test\r config :logger, level: :warning\r \r # Only in tests, remove the complexity from the password hashing algorithm\r config :bcrypt_elixir, :log_rounds, 1\r \r """ assert :already_injected = Injector.test_config_inject(input, hashing_library) end test "returns {:error, :unable_to_inject} when file doesn't confine \"import Config\" or \"use Mix.Config\"" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") input = "" assert {:error, :unable_to_inject} = Injector.test_config_inject(input, hashing_library) end end describe "test_config_help_text/2" do test "returns a string with the expected help text" do {:ok, hashing_library} = HashingLibrary.build("bcrypt") file_path = Path.expand("config/test.exs") assert Injector.test_config_help_text(file_path, hashing_library) == """ Add the following to config/test.exs: # Only in tests, remove the complexity from the password hashing algorithm config :bcrypt_elixir, :log_rounds, 1 """ end end describe "router_plug_inject/2" do test "injects after :put_secure_browser_headers" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) context = Context.new("Accounts", schema, []) binding = [schema: schema, context: context, scope_config: %{scope: %{assign_key: :current_scope}}] input = """ defmodule DemoWeb.Router do use DemoWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_flash plug :protect_from_forgery plug :put_secure_browser_headers end end """ {:ok, injected} = Injector.router_plug_inject(input, binding) assert injected == """ defmodule DemoWeb.Router do use DemoWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_flash plug :protect_from_forgery plug :put_secure_browser_headers plug :fetch_current_scope_for_user end end """ end test "injects after :put_secure_browser_headers even when it has additional options" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) context = Context.new("Accounts", schema, []) binding = [schema: schema, context: context, scope_config: %{scope: %{assign_key: :current_scope}}] input = """ defmodule DemoWeb.Router do use DemoWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_flash plug :protect_from_forgery plug :put_secure_browser_headers, %{"content-security-policy" => @csp} end end """ {:ok, injected} = Injector.router_plug_inject(input, binding) assert injected == """ defmodule DemoWeb.Router do use DemoWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_flash plug :protect_from_forgery plug :put_secure_browser_headers, %{"content-security-policy" => @csp} plug :fetch_current_scope_for_user end end """ end test "respects windows line endings" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) context = Context.new("Accounts", schema, []) binding = [schema: schema, context: context, scope_config: %{scope: %{assign_key: :current_scope}}] input = """ defmodule DemoWeb.Router do\r use DemoWeb, :router\r \r pipeline :browser do\r plug :accepts, ["html"]\r plug :fetch_session\r plug :fetch_flash\r plug :protect_from_forgery\r plug :put_secure_browser_headers\r end\r end\r """ {:ok, injected} = Injector.router_plug_inject(input, binding) assert injected == """ defmodule DemoWeb.Router do\r use DemoWeb, :router\r \r pipeline :browser do\r plug :accepts, ["html"]\r plug :fetch_session\r plug :fetch_flash\r plug :protect_from_forgery\r plug :put_secure_browser_headers\r plug :fetch_current_scope_for_user\r end\r end\r """ end test "errors when :put_secure_browser_headers_is_missing" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) context = Context.new("Accounts", schema, []) binding = [schema: schema, context: context, scope_config: %{scope: %{assign_key: :current_scope}}] input = """ defmodule DemoWeb.Router do use DemoWeb, :router pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_flash plug :protect_from_forgery end end """ assert {:error, :unable_to_inject} = Injector.router_plug_inject(input, binding) end end describe "router_plug_help_text/2" do test "returns a string with the expected help text" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) context = Context.new("Accounts", schema, []) binding = [schema: schema, context: context, scope_config: %{scope: %{assign_key: :current_scope}}] file_path = Path.expand("foo.ex") assert Injector.router_plug_help_text(file_path, binding) == """ Add the :fetch_current_scope_for_user plug to the :browser pipeline in foo.ex: pipeline :browser do ... plug :put_secure_browser_headers plug :fetch_current_scope_for_user end """ end test "adheres to the --assign-key" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) context = Context.new("Accounts", schema, []) binding = [schema: schema, context: context, scope_config: %{scope: %{assign_key: :current_user_scope}}] file_path = Path.expand("foo.ex") assert Injector.router_plug_help_text(file_path, binding) == """ Add the :fetch_current_user_scope_for_user plug to the :browser pipeline in foo.ex: pipeline :browser do ... plug :put_secure_browser_headers plug :fetch_current_user_scope_for_user end """ end end describe "app_layout_menu_inject/2" do test "injects user menu at the bottom of nav section when it exists" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) binding = [schema: schema, scope_config: %{scope: %{assign_key: :current_scope}}] template = """ Demo · Phoenix Framework
""" {:ok, template_str} = Injector.app_layout_menu_inject(binding, template) assert template_str == """ Demo · Phoenix Framework
""" end test "injects user menu at the bottom of nav section when it exists with windows line endings" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) binding = [schema: schema, scope_config: %{scope: %{assign_key: :current_scope}}] template = """ \r \r \r Demo · Phoenix Framework\r \r \r
\r
\r \r
\r
\r \r \r """ {:ok, template_str} = Injector.app_layout_menu_inject(binding, template) assert template_str == """ \r \r \r Demo · Phoenix Framework\r \r \r
\r
\r \r
\r
\r \r \r """ end test "injects render user_menu after the opening body tag" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) binding = [schema: schema, scope_config: %{scope: %{assign_key: :current_scope}}] template = """ Demo · Phoenix Framework
{@inner_content}
""" {:ok, template_str} = Injector.app_layout_menu_inject(binding, template) assert template_str == """ Demo · Phoenix Framework
    <%= if @current_scope do %>
  • {@current_scope.user.email}
  • <.link href={~p"/users/settings"}>Settings
  • <.link href={~p"/users/log-out"} method="delete">Log out
    • <% else %>
  • <.link href={~p"/users/register"}>Register
  • <.link href={~p"/users/log-in"}>Log in
    • <% end %>
{@inner_content}
""" end test "works with windows line endings" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) binding = [schema: schema, scope_config: %{scope: %{assign_key: :current_scope}}] template = """ \r \r \r Demo · Phoenix Framework\r \r \r
\r \r \r {@inner_content}\r
\r \r \r """ {:ok, template_str} = Injector.app_layout_menu_inject(binding, template) assert template_str == """ \r \r \r Demo · Phoenix Framework\r \r \r
    \r <%= if @current_scope do %>\r
  • \r {@current_scope.user.email}\r
    • \r
  • \r <.link href={~p"/users/settings"}>Settings\r
    • \r
  • \r <.link href={~p"/users/log-out"} method="delete">Log out\r
    • \r <% else %>\r
  • \r <.link href={~p"/users/register"}>Register\r
    • \r
  • \r <.link href={~p"/users/log-in"}>Log in\r
    • \r <% end %>\r
\r
\r \r \r {@inner_content}\r
\r \r \r """ end test "returns :already_injected when render is already found in file" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) binding = [schema: schema, scope_config: %{scope: %{assign_key: :current_scope}}] template = """ Demo · Phoenix Framework
    <%= if @current_user do %>
  • {@current_user.email}
  • <.link href={~p"/users/settings"}>Settings
  • <.link href={~p"/users/log-out"} method="delete">Log out
    • <% else %>
  • <.link href={~p"/users/register"}>Register
  • <.link href={~p"/users/log-in"}>Log in
    • <% end %>
{@inner_content}
""" assert :already_injected = Injector.app_layout_menu_inject(binding, template) end test "returns {:error, :unable_to_inject} when the body tag isn't found" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) binding = [schema: schema, scope_config: %{scope: %{assign_key: :current_scope}}] assert {:error, :unable_to_inject} = Injector.app_layout_menu_inject(binding, "") end end describe "app_layout_menu_help_text/2" do test "returns a string with the expected help text" do schema = Schema.new("Accounts.User", "users", [], [no_scope: true]) binding = [schema: schema, scope_config: %{scope: %{assign_key: :current_scope}}] file_path = Path.expand("foo.ex") assert Injector.app_layout_menu_help_text(file_path, binding) =~ "Add the following user menu" end end end ================================================ FILE: test/mix/tasks/phx.gen.auth_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.Gen.AuthTest do use ExUnit.Case @moduletag :mix_phx_new @liveview_option_message "Do you want to create a LiveView based authentication system?" import MixHelper alias Mix.Tasks.Phx.Gen setup do Mix.Task.clear() :ok end defp in_tmp_phx_project(test, additional_args \\ [], func) do in_tmp(test, fn -> Mix.Tasks.Phx.New.run(~w(my_app --no-install) ++ additional_args) in_project(:my_app, "my_app", fn _module -> func.() end) end) end defp in_tmp_phx_umbrella_project(test, func) do in_tmp(test, fn -> Mix.Tasks.Phx.New.run(~w(my_app --umbrella --no-install)) File.cd!("my_app_umbrella", fn -> func.() end) end) end test "invalid mix arguments", config do in_tmp_phx_project(config.test, fn -> assert_raise Mix.Error, ~r/Expected the context, "accounts", to be a valid module name.*phx\.gen\.auth/s, fn -> Gen.Auth.run(~w(accounts User users)) end assert_raise Mix.Error, ~r/Expected the schema, "user", to be a valid module name/, fn -> Gen.Auth.run(~w(Accounts user users)) end assert_raise Mix.Error, ~r/The context and schema should have different names/, fn -> Gen.Auth.run(~w(User User users)) end assert_raise Mix.Error, ~r/Cannot generate context MyApp because it has the same name as the application/, fn -> Gen.Auth.run(~w(MyApp User users)) end assert_raise Mix.Error, ~r/Cannot generate schema MyApp because it has the same name as the application/, fn -> Gen.Auth.run(~w(Accounts MyApp users)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Auth.run(~w()) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Auth.run(~w(Accounts)) end assert_raise Mix.Error, ~r/Invalid arguments.*phx\.gen\.auth/s, fn -> Gen.Auth.run(~w(Accounts User users name:string)) end assert_raise OptionParser.ParseError, ~r/unknown option/i, fn -> Gen.Auth.run(~w(Accounts User users --no-schema)) end assert_raise Mix.Error, ~r/Unknown value for --hashing-lib/, fn -> Gen.Auth.run(~w(Accounts User users --hashing-lib unknown)) end assert_raise Mix.Error, ~r/expects a context module name/, fn -> Gen.Auth.run(~w(User users)) end end) end test "generates with defaults (Prompt: --no-live)", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("config/config.exs", fn file -> assert file =~ """ config :my_app, :scopes, user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users, test_data_fixture: MyApp.AccountsFixtures, test_setup_helper: :register_and_log_in_user ] """ end) assert_file("config/test.exs", fn file -> assert file =~ "config :bcrypt_elixir, :log_rounds, 1" end) assert_file("lib/my_app/accounts.ex") assert_file("lib/my_app/accounts/user.ex") assert_file("lib/my_app/accounts/user_token.ex") assert_file("lib/my_app/accounts/scope.ex", fn file -> assert file =~ "def for_user(%User{} = user)" assert file =~ "def for_user(nil), do: nil" end) assert_file("lib/my_app/accounts/user_notifier.ex", fn file -> assert file =~ "defmodule MyApp.Accounts.UserNotifier do" assert file =~ "import Swoosh.Email" assert file =~ "Mailer.deliver(email)" assert file =~ ~s|from({"MyApp", "contact@example.com"})| assert file =~ ~s|deliver(user.email, "Confirmation instructions",| assert file =~ ~s|deliver(user.email, "Log in instructions",| assert file =~ ~s|deliver(user.email, "Update email instructions",| end) assert_file("test/my_app/accounts_test.exs") assert_file("test/support/fixtures/accounts_fixtures.ex") assert_file("lib/my_app_web/user_auth.ex") assert_file("test/my_app_web/user_auth_test.exs") assert_file("lib/my_app_web/controllers/user_registration_controller.ex") assert_file("lib/my_app_web/controllers/user_registration_html.ex") assert_file("test/my_app_web/controllers/user_registration_controller_test.exs") assert_file("lib/my_app_web/controllers/user_session_controller.ex") assert_file("lib/my_app_web/controllers/user_session_html/new.html.heex") assert_file("test/my_app_web/controllers/user_session_controller_test.exs") assert_file("lib/my_app_web/controllers/user_session_html.ex") assert_file("lib/my_app_web/controllers/user_settings_controller.ex") assert_file("lib/my_app_web/controllers/user_settings_html/edit.html.heex") assert_file("lib/my_app_web/controllers/user_settings_html.ex") assert_file("test/my_app_web/controllers/user_settings_controller_test.exs") assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ "create table(:users) do" assert file =~ "create table(:users_tokens) do" end) assert_file("mix.exs", fn file -> assert file =~ ~s|{:bcrypt_elixir, "~> 3.0"},| end) assert_file("lib/my_app_web/router.ex", fn file -> assert file =~ "import MyAppWeb.UserAuth" assert file =~ "plug :fetch_current_scope_for_user" assert file =~ """ ## Authentication routes scope "/", MyAppWeb do pipe_through [:browser, :redirect_if_user_is_authenticated] get "/users/register", UserRegistrationController, :new post "/users/register", UserRegistrationController, :create end scope "/", MyAppWeb do pipe_through [:browser, :require_authenticated_user] get "/users/settings", UserSettingsController, :edit put "/users/settings", UserSettingsController, :update get "/users/settings/confirm-email/:token", UserSettingsController, :confirm_email end scope "/", MyAppWeb do pipe_through [:browser] get "/users/log-in", UserSessionController, :new get "/users/log-in/:token", UserSessionController, :confirm post "/users/log-in", UserSessionController, :create delete "/users/log-out", UserSessionController, :delete end """ end) assert_file("lib/my_app_web/components/layouts/root.html.heex", fn file -> assert file =~ ~r|<.link.*href={~p"/users/settings"}.*>|s assert file =~ ~r|<.link.*href={~p"/users/log-out"}.*method="delete".*>|s assert file =~ ~r|<.link.*href={~p"/users/register"}.*>|s assert file =~ ~r|<.link.*href={~p"/users/log-in"}.*>|s end) assert_file("test/support/conn_case.ex", fn file -> assert file =~ "def register_and_log_in_user(%{conn: conn} = context)" assert file =~ "def log_in_user(conn, user, opts \\\\ [])" end) assert_received {:mix_shell, :info, ["Unable to find the \"MyApp.Mailer\"" <> mailer_notice]} assert mailer_notice =~ ~s(A mailer module like the following is expected to be defined) assert mailer_notice =~ ~s(in your application in order to send emails.) assert mailer_notice =~ ~s(defmodule MyApp.Mailer do) assert mailer_notice =~ ~s(use Swoosh.Mailer, otp_app: :my_app) assert mailer_notice =~ ~s(def deps do) assert mailer_notice =~ ~s(https://hexdocs.pm/swoosh) end) end test "generates with defaults (Prompt: --live)", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, true}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("config/config.exs", fn file -> assert file =~ """ config :my_app, :scopes, user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users, test_data_fixture: MyApp.AccountsFixtures, test_setup_helper: :register_and_log_in_user ] """ end) assert_file("config/test.exs", fn file -> assert file =~ "config :bcrypt_elixir, :log_rounds, 1" end) assert_file("lib/my_app/accounts.ex") assert_file("lib/my_app/accounts/user.ex") assert_file("lib/my_app/accounts/user_token.ex") assert_file("lib/my_app/accounts/scope.ex", fn file -> assert file =~ "def for_user(%User{} = user)" assert file =~ "def for_user(nil), do: nil" end) assert_file("lib/my_app/accounts/user_notifier.ex", fn file -> assert file =~ "defmodule MyApp.Accounts.UserNotifier do" assert file =~ "import Swoosh.Email" assert file =~ "Mailer.deliver(email)" assert file =~ ~s|from({"MyApp", "contact@example.com"})| assert file =~ ~s|deliver(user.email, "Confirmation instructions",| assert file =~ ~s|deliver(user.email, "Log in instructions",| assert file =~ ~s|deliver(user.email, "Update email instructions",| end) assert_file("lib/my_app_web/live/user_live/registration.ex") assert_file("test/my_app_web/live/user_live/registration_test.exs") assert_file("lib/my_app_web/live/user_live/login.ex") assert_file("test/my_app_web/live/user_live/login_test.exs") assert_file("lib/my_app_web/live/user_live/settings.ex") assert_file("test/my_app_web/live/user_live/settings_test.exs") assert_file("lib/my_app_web/live/user_live/confirmation.ex") assert_file("test/my_app_web/live/user_live/confirmation_test.exs") assert_file("lib/my_app_web/user_auth.ex") assert_file("test/my_app_web/user_auth_test.exs") assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ "create table(:users) do" assert file =~ "create table(:users_tokens) do" end) assert_file("mix.exs", fn file -> assert file =~ ~s|{:bcrypt_elixir, "~> 3.0"},| end) assert_file("lib/my_app_web/router.ex", fn file -> assert file =~ "import MyAppWeb.UserAuth" assert file =~ "plug :fetch_current_scope_for_user" assert file =~ """ ## Authentication routes scope "/", MyAppWeb do pipe_through [:browser, :require_authenticated_user] live_session :require_authenticated_user, on_mount: [{MyAppWeb.UserAuth, :require_authenticated}] do live "/users/settings", UserLive.Settings, :edit live "/users/settings/confirm-email/:token", UserLive.Settings, :confirm_email end post "/users/update-password", UserSessionController, :update_password end scope "/", MyAppWeb do pipe_through [:browser] live_session :current_user, on_mount: [{MyAppWeb.UserAuth, :mount_current_scope}] do live "/users/register", UserLive.Registration, :new live "/users/log-in", UserLive.Login, :new live "/users/log-in/:token", UserLive.Confirmation, :new end post "/users/log-in", UserSessionController, :create delete "/users/log-out", UserSessionController, :delete end """ end) assert_file("lib/my_app_web/components/layouts/root.html.heex", fn file -> assert file =~ ~r|<\.link.*href={~p"/users/settings"}.*>|s assert file =~ ~r|<\.link.*href={~p"/users/log-out"}.*method="delete".*>|s assert file =~ ~r|<\.link.*href={~p"/users/register"}.*>|s assert file =~ ~r|<\.link.*href={~p"/users/log-in"}.*>|s end) assert_file("test/support/conn_case.ex", fn file -> assert file =~ "def register_and_log_in_user(%{conn: conn} = context)" assert file =~ "def log_in_user(conn, user, opts \\\\ [])" end) assert_received {:mix_shell, :info, ["Unable to find the \"MyApp.Mailer\"" <> mailer_notice]} assert mailer_notice =~ ~s(A mailer module like the following is expected to be defined) assert mailer_notice =~ ~s(in your application in order to send emails.) assert mailer_notice =~ ~s(defmodule MyApp.Mailer do) assert mailer_notice =~ ~s(use Swoosh.Mailer, otp_app: :my_app) assert mailer_notice =~ ~s(def deps do) assert mailer_notice =~ ~s(https://hexdocs.pm/swoosh) end) end test "works with apps generated with --live", config do in_tmp_phx_project(config.test, ~w(--live), fn -> Gen.Auth.run( ~w(Accounts User users --live --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_file("lib/my_app_web/components/layouts/root.html.heex", fn file -> assert file =~ ~r|<.link.*href={~p"/users/settings"}.*>|s assert file =~ ~r|<.link.*href={~p"/users/log-out"}.*method="delete".*>|s assert file =~ ~r|<.link.*href={~p"/users/register"}.*>|s assert file =~ ~r|<.link.*href={~p"/users/log-in"}.*>|s end) assert_file("lib/my_app_web/router.ex", fn file -> assert file =~ "import MyAppWeb.UserAuth" assert file =~ "plug :fetch_current_scope_for_user" assert file =~ """ ## Authentication routes scope "/", MyAppWeb do pipe_through [:browser, :require_authenticated_user] live_session :require_authenticated_user, on_mount: [{MyAppWeb.UserAuth, :require_authenticated}] do live "/users/settings", UserLive.Settings, :edit live "/users/settings/confirm-email/:token", UserLive.Settings, :confirm_email end post "/users/update-password", UserSessionController, :update_password end scope "/", MyAppWeb do pipe_through [:browser] live_session :current_user, on_mount: [{MyAppWeb.UserAuth, :mount_current_scope}] do live "/users/register", UserLive.Registration, :new live "/users/log-in", UserLive.Login, :new live "/users/log-in/:token", UserLive.Confirmation, :new end post "/users/log-in", UserSessionController, :create delete "/users/log-out", UserSessionController, :delete end """ end) end) end test "works with apps generated with --no-live", config do in_tmp_phx_project(config.test, ~w(--no-live), fn -> Gen.Auth.run( ~w(Accounts User users --no-live --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_file("lib/my_app_web/components/layouts/root.html.heex", fn file -> assert file =~ ~r|<.link.*href={~p"/users/settings"}.*>|s assert file =~ ~r|<.link.*href={~p"/users/log-out"}.*method="delete".*>|s assert file =~ ~r|<.link.*href={~p"/users/register"}.*>|s assert file =~ ~r|<.link.*href={~p"/users/log-in"}.*>|s end) assert_file("lib/my_app_web/router.ex", fn file -> assert file =~ "import MyAppWeb.UserAuth" assert file =~ "plug :fetch_current_scope_for_user" assert file =~ """ ## Authentication routes scope "/", MyAppWeb do pipe_through [:browser, :redirect_if_user_is_authenticated] get "/users/register", UserRegistrationController, :new post "/users/register", UserRegistrationController, :create end scope "/", MyAppWeb do pipe_through [:browser, :require_authenticated_user] get "/users/settings", UserSettingsController, :edit put "/users/settings", UserSettingsController, :update get "/users/settings/confirm-email/:token", UserSettingsController, :confirm_email end scope "/", MyAppWeb do pipe_through [:browser] get "/users/log-in", UserSessionController, :new get "/users/log-in/:token", UserSessionController, :confirm post "/users/log-in", UserSessionController, :create delete "/users/log-out", UserSessionController, :delete end """ end) end) end test "generates with --web option", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --web warehouse --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("lib/my_app/accounts.ex") assert_file("lib/my_app/accounts/user.ex") assert_file("lib/my_app/accounts/user_token.ex") assert_file("lib/my_app/accounts/user_notifier.ex") assert_file("test/my_app/accounts_test.exs") assert_file("test/support/fixtures/accounts_fixtures.ex", fn file -> assert file =~ ~s|def valid_user_attributes(attrs \\\\ %{}) do| end) assert_file("lib/my_app_web/warehouse/user_auth.ex", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserAuth do" end) assert_file("test/my_app_web/warehouse/user_auth_test.exs", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserAuthTest do" end) assert_file("lib/my_app_web/components/layouts/root.html.heex", fn file -> assert file =~ ~r|<\.link.*href={~p"/warehouse/users/settings"}.*>|s assert file =~ ~r|<\.link.*href={~p"/warehouse/users/log-out"}.*method="delete".*>|s assert file =~ ~r|<\.link.*href={~p"/warehouse/users/register"}.*>|s assert file =~ ~r|<\.link.*href={~p"/warehouse/users/log-in"}.*>|s end) assert_file( "lib/my_app_web/controllers/warehouse/user_registration_controller.ex", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserRegistrationController do" end ) assert_file("lib/my_app_web/controllers/warehouse/user_registration_html.ex", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserRegistrationHTML do" end) assert_file( "test/my_app_web/controllers/warehouse/user_registration_controller_test.exs", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserRegistrationControllerTest do" end ) assert_file("lib/my_app_web/controllers/warehouse/user_session_controller.ex", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserSessionController do" end) assert_file( "lib/my_app_web/controllers/warehouse/user_session_html/new.html.heex", fn file -> assert file =~ ~S|<.form :let={f} for={@form} as={:user} id="login_form_magic" action={~p"/warehouse/users/log-in"}>| assert file =~ """ <.form :let={f} for={@form} as={:user} id="login_form_password" action={~p"/warehouse/users/log-in"}> """ assert file =~ ~S|navigate={~p"/warehouse/users/register"}| end ) assert_file( "test/my_app_web/controllers/warehouse/user_session_controller_test.exs", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserSessionControllerTest do" end ) assert_file("lib/my_app_web/controllers/warehouse/user_session_html.ex", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserSessionHTML do" end) assert_file("lib/my_app_web/controllers/warehouse/user_settings_controller.ex", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserSettingsController do" end) assert_file( "lib/my_app_web/controllers/warehouse/user_settings_html/edit.html.heex", fn file -> assert file =~ ~S|<.form :let={f} for={@email_changeset} action={~p"/warehouse/users/settings"} id="update_email">| assert file =~ ~s|<.form :let={f} for={@password_changeset} action={~p\"/warehouse/users/settings\"} id=\"update_password\">| end ) assert_file("lib/my_app_web/controllers/warehouse/user_settings_html.ex", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserSettingsHTML do" end) assert_file( "test/my_app_web/controllers/warehouse/user_settings_controller_test.exs", fn file -> assert file =~ "defmodule MyAppWeb.Warehouse.UserSettingsControllerTest do" end ) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ "create table(:users) do" assert file =~ "create table(:users_tokens) do" end) assert_file("lib/my_app_web/router.ex", fn file -> assert file =~ "import MyAppWeb.Warehouse.UserAuth" assert file =~ "plug :fetch_current_scope_for_user" assert file =~ """ ## Authentication routes scope "/warehouse", MyAppWeb.Warehouse do pipe_through [:browser, :redirect_if_user_is_authenticated] get "/users/register", UserRegistrationController, :new post "/users/register", UserRegistrationController, :create end scope "/warehouse", MyAppWeb.Warehouse do pipe_through [:browser, :require_authenticated_user] get "/users/settings", UserSettingsController, :edit put "/users/settings", UserSettingsController, :update get "/users/settings/confirm-email/:token", UserSettingsController, :confirm_email end scope "/warehouse", MyAppWeb.Warehouse do pipe_through [:browser] get "/users/log-in", UserSessionController, :new get "/users/log-in/:token", UserSessionController, :confirm post "/users/log-in", UserSessionController, :create delete "/users/log-out", UserSessionController, :delete end """ end) assert_file("test/support/conn_case.ex", fn file -> assert file =~ "def register_and_log_in_user(%{conn: conn} = context)" assert file =~ "def log_in_user(conn, user, opts \\\\ [])" end) end) end describe "--database option" do test "when the database is postgres", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ ~r/execute "CREATE EXTENSION IF NOT EXISTS citext", ""$/m assert file =~ ~r/add :email, :citext, null: false$/m end) assert_file("test/my_app_web/user_auth_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase, async: true$/m end) assert_file( "test/my_app_web/controllers/user_registration_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase, async: true$/m end ) assert_file("test/my_app_web/controllers/user_session_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase, async: true$/m end) assert_file("test/my_app_web/controllers/user_settings_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase, async: true$/m end) end) end test "when the database is mysql", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.MyXQL ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> refute file =~ ~r/execute "CREATE EXTENSION IF NOT EXISTS citext", ""$/m assert file =~ ~r/add :email, :string, null: false, size: 160$/m end) assert_file("test/my_app_web/user_auth_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) assert_file( "test/my_app_web/controllers/user_registration_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end ) assert_file("test/my_app_web/controllers/user_session_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) assert_file("test/my_app_web/controllers/user_settings_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) end) end test "when the database is sqlite3", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.SQLite3 ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> refute file =~ ~r/execute "CREATE EXTENSION IF NOT EXISTS citext", ""$/m assert file =~ ~r/add :email, :string, null: false, collate: :nocase$/m end) assert_file("test/my_app_web/user_auth_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) assert_file( "test/my_app_web/controllers/user_registration_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end ) assert_file("test/my_app_web/controllers/user_session_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) assert_file("test/my_app_web/controllers/user_settings_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) end) end test "when the database is mssql", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.TDS ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> refute file =~ ~r/execute "CREATE EXTENSION IF NOT EXISTS citext", ""$/m assert file =~ ~r/add :email, :string, null: false, size: 160$/m end) assert_file("test/my_app_web/user_auth_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) assert_file( "test/my_app_web/controllers/user_registration_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end ) assert_file("test/my_app_web/controllers/user_session_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) assert_file("test/my_app_web/controllers/user_settings_controller_test.exs", fn file -> assert file =~ ~r/use MyAppWeb\.ConnCase$/m end) end) end end test "allows utc_datetime", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) with_generator_env(:my_app, [timestamp_type: :utc_datetime], fn -> Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ "timestamps(type: :utc_datetime)" assert file =~ "timestamps(type: :utc_datetime, updated_at: false)" end) assert_file("lib/my_app/accounts/user.ex", fn file -> assert file =~ "field :confirmed_at, :utc_datetime" assert file =~ "timestamps(type: :utc_datetime)" assert file =~ "now = DateTime.utc_now(:second)" end) assert_file("lib/my_app/accounts/user_token.ex", fn file -> assert file =~ "timestamps(type: :utc_datetime, updated_at: false)" end) assert_file("lib/my_app/accounts.ex", fn file -> assert file =~ "sudo_mode?(%User{authenticated_at: ts}, minutes) when is_struct(ts, DateTime)" end) end) end) end test "generates migration with a custom migration module", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) try do Application.put_env(:ecto_sql, :migration_module, MyCustomApp.MigrationModule) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ "use MyCustomApp.MigrationModule" end) after Application.delete_env(:ecto_sql, :migration_module) end end) end test "supports --binary-id option", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --binary-id --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("lib/my_app/accounts/user.ex", fn file -> assert file =~ "@primary_key {:id, :binary_id, autogenerate: true}" assert file =~ "@foreign_key_type :binary_id" end) assert_file("lib/my_app/accounts/user_token.ex", fn file -> assert file =~ "@primary_key {:id, :binary_id, autogenerate: true}" assert file =~ "@foreign_key_type :binary_id" end) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ "create table(:users, primary_key: false)" assert file =~ "create table(:users_tokens, primary_key: false)" assert file =~ "add :id, :binary_id, primary_key: true" end) end) end describe "--hashing-lib option" do test "when bcrypt", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --hashing-lib bcrypt --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("mix.exs", fn file -> assert file =~ ~s|{:bcrypt_elixir, "~> 3.0"}| end) assert_file("config/test.exs", fn file -> assert file =~ "config :bcrypt_elixir, :log_rounds, 1" end) assert_file("lib/my_app/accounts/user.ex", fn file -> assert file =~ "Bcrypt.verify_pass(password, hashed_password)" end) end) end test "when pbkdf2", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --hashing-lib pbkdf2 --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("mix.exs", fn file -> assert file =~ ~s|{:pbkdf2_elixir, "~> 2.0"}| end) assert_file("config/test.exs", fn file -> assert file =~ "config :pbkdf2_elixir, :rounds, 1" end) assert_file("lib/my_app/accounts/user.ex", fn file -> assert file =~ "Pbkdf2.verify_pass(password, hashed_password)" end) end) end test "when argon2", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --hashing-lib argon2 --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("mix.exs", fn file -> assert file =~ ~s|{:argon2_elixir, "~> 4.0"}| end) assert_file("config/test.exs", fn file -> assert file =~ """ config :argon2_elixir, t_cost: 1, m_cost: 8 """ end) assert_file("lib/my_app/accounts/user.ex", fn file -> assert file =~ "Argon2.verify_pass(password, hashed_password)" end) end) end end test "with --table option", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --table my_users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("lib/my_app/accounts/user.ex", fn file -> assert file =~ ~S|schema "my_users" do| end) assert_file("lib/my_app/accounts/user_token.ex", fn file -> assert file =~ ~S|schema "my_users_tokens" do| end) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_my_users_auth_tables.exs") assert_file(migration, fn file -> assert file =~ "create table(:my_users) do" assert file =~ "create table(:my_users_tokens) do" end) end) end describe "inside umbrella" do test "without context_app generators config uses web dir", config do in_tmp_phx_umbrella_project(config.test, fn -> in_project(:my_app, "apps/my_app", fn _module -> with_generator_env(:my_app_web, [context_app: nil], fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} end) end) assert_file("apps/my_app/lib/my_app/accounts.ex") assert_file("apps/my_app/lib/my_app/accounts/user.ex") assert_file("apps/my_app/lib/my_app/accounts/user_token.ex") assert_file("apps/my_app/lib/my_app/accounts/user_notifier.ex") assert_file("apps/my_app/test/my_app/accounts_test.exs") assert_file("apps/my_app/test/support/fixtures/accounts_fixtures.ex") assert_file("apps/my_app/lib/my_app_web/user_auth.ex") assert_file("apps/my_app/test/my_app_web/user_auth_test.exs") assert_file("apps/my_app/lib/my_app_web/controllers/user_registration_controller.ex") assert_file("apps/my_app/lib/my_app_web/controllers/user_registration_html.ex") assert_file( "apps/my_app/test/my_app_web/controllers/user_registration_controller_test.exs" ) assert_file("apps/my_app/lib/my_app_web/controllers/user_session_controller.ex") assert_file("apps/my_app/lib/my_app_web/controllers/user_session_html/new.html.heex") assert_file("apps/my_app/test/my_app_web/controllers/user_session_controller_test.exs") assert_file("apps/my_app/lib/my_app_web/controllers/user_session_html.ex") assert_file("apps/my_app/lib/my_app_web/controllers/user_settings_controller.ex") assert_file("apps/my_app/lib/my_app_web/controllers/user_settings_html/edit.html.heex") assert_file("apps/my_app/lib/my_app_web/controllers/user_settings_html.ex") assert_file("apps/my_app/test/my_app_web/controllers/user_settings_controller_test.exs") end) end test "with context_app generators config does not use web dir", config do in_tmp_phx_umbrella_project(config.test, fn -> in_project(:my_app_web, "apps/my_app_web", fn _module -> with_generator_env(:my_app_web, [context_app: :my_app], fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} end) end) assert_file("apps/my_app/lib/my_app/accounts.ex") assert_file("apps/my_app/lib/my_app/accounts/user.ex") assert_file("apps/my_app/lib/my_app/accounts/user_token.ex") assert_file("apps/my_app/lib/my_app/accounts/user_notifier.ex") assert_file("apps/my_app/test/my_app/accounts_test.exs") assert_file("apps/my_app/test/support/fixtures/accounts_fixtures.ex") assert_file("apps/my_app_web/lib/my_app_web/user_auth.ex") assert_file("apps/my_app_web/test/my_app_web/user_auth_test.exs") assert_file("apps/my_app_web/lib/my_app_web/controllers/user_registration_controller.ex") assert_file("apps/my_app_web/lib/my_app_web/controllers/user_registration_html.ex") assert_file( "apps/my_app_web/test/my_app_web/controllers/user_registration_controller_test.exs" ) assert_file("apps/my_app_web/lib/my_app_web/controllers/user_session_controller.ex") assert_file("apps/my_app_web/lib/my_app_web/controllers/user_session_html/new.html.heex") assert_file( "apps/my_app_web/test/my_app_web/controllers/user_session_controller_test.exs" ) assert_file("apps/my_app_web/lib/my_app_web/controllers/user_session_html.ex") assert_file("apps/my_app_web/lib/my_app_web/controllers/user_settings_controller.ex") assert_file( "apps/my_app_web/lib/my_app_web/controllers/user_settings_html/edit.html.heex" ) assert_file("apps/my_app_web/lib/my_app_web/controllers/user_settings_html.ex") assert_file( "apps/my_app_web/test/my_app_web/controllers/user_settings_controller_test.exs" ) end) end test "raises with false context_app", config do in_tmp_phx_umbrella_project(config.test, fn -> in_project(:my_app_web, "apps/my_app_web", fn _module -> with_generator_env(:my_app_web, [context_app: false], fn -> assert_raise Mix.Error, ~r/no context_app configured/, fn -> Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) end end) end) end) end end describe "user prompts" do test "when unable to inject dependencies in mix.exs", config do in_tmp_phx_project(config.test, fn -> File.write!("mix.exs", "") send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_received {:mix_shell, :info, [ """ Add your {:bcrypt_elixir, "~> 3.0"} dependency to mix.exs: defp deps do [ {:bcrypt_elixir, "~> 3.0"}, ... ] end """ ]} end) end test "when unable to inject authentication import into router.ex", config do in_tmp_phx_project(config.test, fn -> modify_file("lib/my_app_web/router.ex", fn file -> String.replace(file, "use MyAppWeb, :router", "") end) send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_received {:mix_shell, :info, [ """ Add your MyAppWeb.UserAuth import to lib/my_app_web/router.ex: defmodule MyAppWeb.Router do use MyAppWeb, :router # Import authentication plugs import MyAppWeb.UserAuth ... end """ ]} end) end test "when unable to inject plugs into router.ex", config do in_tmp_phx_project(config.test, fn -> modify_file("lib/my_app_web/router.ex", fn file -> String.replace(file, "plug :put_secure_browser_headers\n", "") end) send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_received {:mix_shell, :info, [ """ Add the :fetch_current_scope_for_user plug to the :browser pipeline in lib/my_app_web/router.ex: pipeline :browser do ... plug :put_secure_browser_headers plug :fetch_current_scope_for_user end """ ]} end) end test "when layout file is not found", config do in_tmp_phx_project(config.test, fn -> File.rm!("lib/my_app_web/components/layouts/root.html.heex") send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_receive {:mix_shell, :error, [error]} assert error == """ Unable to find the root layout file to inject user menu items. Missing files: * lib/my_app_web/components/layouts/root.html.heex Please ensure this phoenix app was not generated with --no-html. If you have changed the name of your root layout file, please add the following code to it where you'd like the user menu items to be rendered.
    <%= if @current_scope do %>
  • {@current_scope.user.email}
  • <.link href={~p"/users/settings"}>Settings
  • <.link href={~p"/users/log-out"} method="delete">Log out
    • <% else %>
  • <.link href={~p"/users/register"}>Register
  • <.link href={~p"/users/log-in"}>Log in
    • <% end %>
""" end) end test "when user menu can't be injected into layout", config do in_tmp_phx_project(config.test, fn -> modify_file("lib/my_app_web/components/layouts/root.html.heex", fn _file -> "" end) send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} help_text = """ Add the following user menu items to your lib/my_app_web/components/layouts/root.html.heex layout file:
    <%= if @current_scope do %>
  • {@current_scope.user.email}
  • <.link href={~p"/users/settings"}>Settings
  • <.link href={~p"/users/log-out"} method="delete">Log out
    • <% else %>
  • <.link href={~p"/users/register"}>Register
  • <.link href={~p"/users/log-in"}>Log in
    • <% end %>
""" assert_received {:mix_shell, :info, [^help_text]} end) end test "when default scope already exists", config do in_tmp_phx_project(config.test, fn -> with_scope_env( :my_app, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ] ], fn -> send(self(), {:mix_shell_input, :yes?, true}) Gen.Auth.run( ~w(Accounts User users --no-compile --live), ecto_adapter: Ecto.Adapters.Postgres ) help_text = """ Your application configuration already contains a default scope: :user. phx.gen.auth will create a new accounts_user scope. Note that if you run `phx.gen.live` multiple times, the generated assign key for the generated scopes can conflict with each other. You can pass `--assign-key` to customize the assign key for the generated scope. Do you want to proceed with the generation?\ """ assert_received {:mix_shell, :yes?, [question]} assert question == help_text end ) end) end test "when scope name cannot be generated", config do in_tmp_phx_project(config.test, fn -> with_scope_env( :my_app, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ], accounts_user: [ default: false, module: MyApp.Accounts.Scope, access_path: [] ], my_app_accounts_user: [ default: false, module: MyApp.Accounts.Scope, access_path: [] ] ], fn -> send(self(), {:mix_shell_input, :yes?, true}) assert_raise Mix.Error, ~r/Could not generate a scope name for user!/, fn -> Gen.Auth.run( ~w(Accounts User users --no-compile --live), ecto_adapter: Ecto.Adapters.Postgres ) end end ) end) end test "when given scope already exists", config do in_tmp_phx_project(config.test, fn -> with_scope_env( :my_app, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ] ], fn -> send(self(), {:mix_shell_input, :yes?, true}) Gen.Auth.run( ~w(Accounts User users --no-compile --live --scope user), ecto_adapter: Ecto.Adapters.Postgres ) help_text = """ The scope user is already configured. phx.gen.auth expects the configured scope module MyApp.Accounts.Scope to include a `for_user/1` function that returns a `%MyApp.Accounts.User{}` struct: def for_user(nil), do: %__MODULE__{user: nil} def for_user(%<%= inspect schema.alias %>{} = user) do %__MODULE__{user: user} end Please ensure that your scope module includes such code. Do you want to proceed with the generation?\ """ assert_received {:mix_shell, :yes?, [question]} assert question == help_text end ) end) end end test "allows templates to be overridden", config do in_tmp_phx_project(config.test, fn -> File.mkdir_p!("priv/templates/phx.gen.auth") File.write!("priv/templates/phx.gen.auth/auth.ex", "#it works!") send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts Admin admins --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("lib/my_app_web/admin_auth.ex", fn file -> assert file =~ ~S|it works!| end) end) end test "with --no-agents-md does not inject content to AGENTS.md", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-agents-md --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} # AGENTS.md should still exist from phx.new but should not contain phx.gen.auth content assert_file("AGENTS.md", fn file -> refute file =~ "phoenix-gen-auth-start" refute file =~ "phoenix-gen-auth-end" end) end) end test "injects phx.gen.auth content into AGENTS.md at the correct location", config do in_tmp_phx_project(config.test, fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} # Should inject content before usage-rules-start assert_file("AGENTS.md", fn file -> assert file =~ "phoenix-gen-auth-start" assert file =~ "phoenix-gen-auth-end" assert file =~ "usage-rules-start" # Verify the order: gen.auth content comes before usage-rules auth_start_pos = :binary.match(file, "phoenix-gen-auth-start") |> elem(0) usage_rules_pos = :binary.match(file, "usage-rules-start") |> elem(0) assert auth_start_pos < usage_rules_pos end) end) end test "does not duplicate phx.gen.auth content when run multiple times", config do in_tmp_phx_project(config.test, fn -> # First run send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Accounts User users --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} # Second run with different schema send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Admins Admin admins --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} # Should only have one instance of the gen.auth markers assert_file("AGENTS.md", fn file -> auth_start_matches = Regex.scan(~r/phoenix-gen-auth-start/, file) assert length(auth_start_matches) == 1 auth_end_matches = Regex.scan(~r/phoenix-gen-auth-end/, file) assert length(auth_end_matches) == 1 end) end) end test "injects different content for --live vs non-live", config do in_tmp_phx_project(config.test, fn -> # First test with --live Gen.Auth.run( ~w(Accounts User users --live --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_file("AGENTS.md", fn file -> # Check for LiveView-specific content assert file =~ "live_session" assert file =~ "LiveViews that require login" assert file =~ "live_session :require_authenticated_user" assert file =~ "live_session :current_user" assert file =~ "on_mount:" assert file =~ "MyAppWeb.UserAuth, :require_authenticated" assert file =~ "MyAppWeb.UserAuth, :mount_current_scope" assert file =~ "or LiveViews" assert file =~ "**Never** duplicate `live_session` names" end) # Clean up AGENTS.md for second test File.rm!("AGENTS.md") # Re-create it as phx.new would File.write!("AGENTS.md", """ ## Project-specific information """) # Now test without --live send(self(), {:mix_shell_input, :yes?, false}) Gen.Auth.run( ~w(Admins Admin admins --no-compile), ecto_adapter: Ecto.Adapters.Postgres ) assert_received {:mix_shell, :yes?, [@liveview_option_message]} assert_file("AGENTS.md", fn file -> # Should not have LiveView-specific content refute file =~ "live_session" refute file =~ "LiveViews that require login" refute file =~ "on_mount:" refute file =~ "or LiveViews" refute file =~ "**Never** duplicate `live_session` names" # But should still have general auth content assert file =~ "Authentication" assert file =~ "require_authenticated_admin" assert file =~ "Controller routes must be placed" end) end) end end ================================================ FILE: test/mix/tasks/phx.gen.cert_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.CertTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen @timeout 5_000 test "write certificate and key files" do in_tmp("mix_phx_gen_cert", fn -> Gen.Cert.run([]) assert_received {:mix_shell, :info, ["* creating priv/cert/selfsigned_key.pem"]} assert_received {:mix_shell, :info, ["* creating priv/cert/selfsigned.pem"]} assert_file("priv/cert/selfsigned_key.pem", "-----BEGIN RSA PRIVATE KEY-----") assert_file("priv/cert/selfsigned.pem", "-----BEGIN CERTIFICATE-----") end) end test "write certificate and key with custom filename" do in_tmp("mix_phx_gen_cert", fn -> Gen.Cert.run(["-o", "priv/cert/localhost"]) assert_received {:mix_shell, :info, ["* creating priv/cert/localhost_key.pem"]} assert_received {:mix_shell, :info, ["* creating priv/cert/localhost.pem"]} assert_file("priv/cert/localhost_key.pem", "-----BEGIN RSA PRIVATE KEY-----") assert_file("priv/cert/localhost.pem", "-----BEGIN CERTIFICATE-----") end) end test "TLS connection with generated certificate and key" do Application.ensure_all_started(:ssl) in_tmp("mix_phx_gen_cert", fn -> Gen.Cert.run([]) assert {:ok, server} = :ssl.listen( 0, certfile: "priv/cert/selfsigned.pem", keyfile: "priv/cert/selfsigned_key.pem" ) {:ok, {_, port}} = :ssl.sockname(server) spawn_link(fn -> with {:ok, conn} <- :ssl.transport_accept(server, @timeout), :ok <- :ssl.handshake(conn, @timeout) do :ssl.close(conn) end end) # We don't actually verify the server cert contents, we just check that # the client and server are able to complete the TLS handshake assert {:ok, client} = :ssl.connect(~c"localhost", port, [verify: :verify_none], @timeout) :ssl.close(client) :ssl.close(server) end) end end ================================================ FILE: test/mix/tasks/phx.gen.channel_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule PhoenixWeb.DupChannel do end defmodule Ecto.Adapters.SQL do end defmodule Mix.Tasks.Phx.Gen.ChannelTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen setup do Mix.Task.clear() :ok end test "generates channel" do in_tmp_project("generates channel", fn -> # Ensure the `user_socket.ex` exists first. Gen.Socket.run(["User"]) Gen.Channel.run(["Room"]) assert_file("lib/phoenix_web/channels/room_channel.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannel do| assert file =~ ~S|use PhoenixWeb, :channel| assert file =~ ~S|def join("room:lobby", payload, socket) do| assert file =~ ~S|def handle_in("ping", payload, socket) do| assert file =~ ~S|{:reply, {:ok, payload}, socket}| assert file =~ ~S|def handle_in("shout", payload, socket) do| assert file =~ ~S|broadcast(socket, "shout", payload)| assert file =~ ~S|{:noreply, socket}| end) assert_file("test/support/channel_case.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.ChannelCase| assert file =~ ~S|@endpoint PhoenixWeb.Endpoint| assert file =~ ~S|Phoenix.DataCase.setup_sandbox| end) assert_file("test/phoenix_web/channels/room_channel_test.exs", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannelTest| assert file =~ ~S|use PhoenixWeb.ChannelCase| assert file =~ ~S|> socket("user_id", %{some: :assign}| assert file =~ ~S|> subscribe_and_join(PhoenixWeb.RoomChannel| assert file =~ ~S|test "ping replies with status ok"| assert file =~ ~S|ref = push(socket, "ping", %{"hello" => "there"})| assert file =~ ~S|assert_reply ref, :ok, %{"hello" => "there"}| assert file =~ ~S|test "shout broadcasts to room:lobby"| assert file =~ ~S|push(socket, "shout", %{"hello" => "all"})| assert file =~ ~S|assert_broadcast "shout", %{"hello" => "all"}| assert file =~ ~S|test "broadcasts are pushed to the client"| assert file =~ ~S|broadcast_from!(socket, "broadcast", %{"some" => "data"})| assert file =~ ~S|assert_push "broadcast", %{"some" => "data"}| end) end) assert_received {:mix_shell, :info, [ """ Add the channel to your `lib/phoenix_web/channels/user_socket.ex` handler, for example: channel "room:lobby", PhoenixWeb.RoomChannel """ ]} end test "generates channel and ask to create UserSocket" do in_tmp_project("generates channel", fn -> # Accepts creation of the UserSocket send(self(), {:mix_shell_input, :yes?, true}) Gen.Channel.run(["Room"]) assert_file("lib/phoenix_web/channels/room_channel.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannel do| assert file =~ ~S|use PhoenixWeb, :channel| end) assert_file("test/phoenix_web/channels/room_channel_test.exs", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannelTest| assert file =~ ~S|use PhoenixWeb.ChannelCase| end) assert_received {:mix_shell, :info, [ "\nThe default socket handler - PhoenixWeb.UserSocket - was not found" <> _ ]} assert_received {:mix_shell, :yes?, [question]} assert question =~ "Do you want to create it?" assert_received {:mix_shell, :info, ["\nAdd the socket handler to your `lib/phoenix_web/endpoint.ex`" <> _]} assert_file("lib/phoenix_web/channels/user_socket.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.UserSocket do| assert file =~ ~S|channel "room:*", PhoenixWeb.RoomChannel| end) end) end test "generates channel and give instructions when UserSocket does not exist" do in_tmp_project("generates channel", fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Channel.run(["Room"]) assert_file("lib/phoenix_web/channels/room_channel.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannel do| assert file =~ ~S|use PhoenixWeb, :channel| end) assert_file("test/phoenix_web/channels/room_channel_test.exs", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannelTest| assert file =~ ~S|use PhoenixWeb.ChannelCase| end) end) assert_received {:mix_shell, :info, ["\nThe default socket handler - PhoenixWeb.UserSocket - was not found" <> _]} assert_received {:mix_shell, :yes?, [question]} assert question =~ "Do you want to create it?" assert_received {:mix_shell, :info, ["\nTo create it, please run the mix task:" <> _]} end test "in an umbrella with a context_app, generates the files" do in_tmp_umbrella_project("generates channels", fn -> send(self(), {:mix_shell_input, :yes?, false}) Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) Gen.Channel.run(["Room"]) assert_file("lib/phoenix/channels/room_channel.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannel do| assert file =~ ~S|use PhoenixWeb, :channel| end) assert_file("test/support/channel_case.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.ChannelCase| assert file =~ ~S|@endpoint PhoenixWeb.Endpoint| assert file =~ ~S|Phoenix.DataCase.setup_sandbox| end) assert_file("test/phoenix/channels/room_channel_test.exs", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomChannelTest| assert file =~ ~S|subscribe_and_join(PhoenixWeb.RoomChannel| end) end) assert_received {:mix_shell, :info, ["\nThe default socket handler - PhoenixWeb.UserSocket - was not found" <> _]} assert_received {:mix_shell, :yes?, [question]} assert question =~ "Do you want to create it?" assert_received {:mix_shell, :info, ["\nTo create it, please run the mix task" <> _]} end test "generates nested channel" do in_tmp_project("generates nested channel", fn -> send(self(), {:mix_shell_input, :yes?, false}) Gen.Channel.run(["Admin.Room"]) assert_file("lib/phoenix_web/channels/admin/room_channel.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.Admin.RoomChannel do| assert file =~ ~S|use PhoenixWeb, :channel| end) assert_file("test/phoenix_web/channels/admin/room_channel_test.exs", fn file -> assert file =~ ~S|defmodule PhoenixWeb.Admin.RoomChannelTest| assert file =~ ~S|use PhoenixWeb.ChannelCase| assert file =~ ~S|subscribe_and_join(PhoenixWeb.Admin.RoomChannel| end) end) assert_received {:mix_shell, :info, ["\nThe default socket handler - PhoenixWeb.UserSocket - was not found" <> _]} assert_received {:mix_shell, :yes?, [question]} assert question =~ "Do you want to create it?" assert_received {:mix_shell, :info, ["\nTo create it, please run the mix task" <> _]} end test "passing no args raises error" do assert_raise Mix.Error, fn -> Gen.Channel.run([]) end end test "passing invalid name raises error" do assert_raise Mix.Error, fn -> Gen.Channel.run(["room"]) end end test "passing extra args raises error" do assert_raise Mix.Error, fn -> Gen.Channel.run(["Admin.Room", "new_message"]) end end test "name is already defined" do assert_raise Mix.Error, ~r/DupChannel is already taken/, fn -> Gen.Channel.run(["Dup"]) end end end ================================================ FILE: test/mix/tasks/phx.gen.context_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Phoenix.DupContext do end defmodule Mix.Tasks.Phx.Gen.ContextTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen alias Mix.Phoenix.{Context, Schema} setup do Mix.Task.clear() :ok end test "new context", config do in_tmp_project(config.test, fn -> schema = Schema.new("Blog.Post", "posts", [], no_scope: true) context = Context.new("Blog", schema, []) assert %Context{ alias: Blog, base_module: Phoenix, basename: "blog", module: Phoenix.Blog, web_module: PhoenixWeb, schema: %Mix.Phoenix.Schema{ alias: Post, human_plural: "Posts", human_singular: "Post", module: Phoenix.Blog.Post, plural: "posts", singular: "post" } } = context assert String.ends_with?(context.dir, "lib/phoenix/blog") assert String.ends_with?(context.file, "lib/phoenix/blog.ex") assert String.ends_with?(context.test_file, "test/phoenix/blog_test.exs") assert String.ends_with?( context.test_fixtures_file, "test/support/fixtures/blog_fixtures.ex" ) assert String.ends_with?(context.schema.file, "lib/phoenix/blog/post.ex") end) end test "optional context name", config do in_tmp_project(config.test, fn -> {context, _} = Mix.Tasks.Phx.Gen.Context.build(["User", "users", "name"], name_optional: true) assert %Context{ alias: Users, base_module: Phoenix, basename: "users", module: Phoenix.Users, web_module: PhoenixWeb, schema: %Mix.Phoenix.Schema{ alias: User, human_plural: "Users", human_singular: "User", module: Phoenix.Users.User, plural: "users", singular: "user" } } = context assert String.ends_with?(context.dir, "lib/phoenix/users") assert String.ends_with?(context.file, "lib/phoenix/users.ex") assert String.ends_with?(context.test_file, "test/phoenix/users_test.exs") assert String.ends_with?( context.test_fixtures_file, "test/support/fixtures/users_fixtures.ex" ) assert String.ends_with?(context.schema.file, "lib/phoenix/users/user.ex") end) end test "optional context name raises if schema is plural", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/Please pass an explicit context option/, fn -> Mix.Tasks.Phx.Gen.Context.build(["Users", "users", "name"], name_optional: true) end end) end test "context name raises is required by default", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/expect a context module name, followed by singular and plural names/, fn -> Mix.Tasks.Phx.Gen.Context.build(["Users", "users", "name"]) end end) end test "new nested context", config do in_tmp_project(config.test, fn -> schema = Schema.new("Site.Blog.Post", "posts", [], no_scope: true) context = Context.new("Site.Blog", schema, []) assert %Context{ alias: Blog, base_module: Phoenix, basename: "blog", module: Phoenix.Site.Blog, web_module: PhoenixWeb, schema: %Mix.Phoenix.Schema{ alias: Post, human_plural: "Posts", human_singular: "Post", module: Phoenix.Site.Blog.Post, plural: "posts", singular: "post" } } = context assert String.ends_with?(context.dir, "lib/phoenix/site/blog") assert String.ends_with?(context.file, "lib/phoenix/site/blog.ex") assert String.ends_with?(context.test_file, "test/phoenix/site/blog_test.exs") assert String.ends_with?( context.test_fixtures_file, "test/support/fixtures/site/blog_fixtures.ex" ) assert String.ends_with?(context.schema.file, "lib/phoenix/site/blog/post.ex") end) end test "new existing context", config do in_tmp_project(config.test, fn -> File.mkdir_p!("lib/phoenix/blog") File.write!("lib/phoenix/blog.ex", """ defmodule Phoenix.Blog do end """) schema = Schema.new("Blog.Post", "posts", [], no_scope: true) context = Context.new("Blog", schema, []) assert Context.pre_existing?(context) refute Context.pre_existing_tests?(context) refute Context.pre_existing_test_fixtures?(context) File.mkdir_p!("test/phoenix/blog") File.write!(context.test_file, """ defmodule Phoenix.BlogTest do end """) assert Context.pre_existing_tests?(context) File.mkdir_p!("test/support/fixtures") File.write!(context.test_fixtures_file, """ defmodule Phoenix.BlogFixtures do end """) assert Context.pre_existing_test_fixtures?(context) end) end test "new with default scope", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ] ], fn -> schema = Schema.new("Blog.Post", "posts", [], []) context = Context.new("Blog", schema, []) assert %Context{ scope: %Mix.Phoenix.Scope{ name: :user, default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users } } = context end ) end) end test "invalid mix arguments", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/Expected the context, "blog", to be a valid module name/, fn -> Gen.Context.run(~w(blog Post posts title:string)) end assert_raise Mix.Error, ~r/Expected the schema, "posts", to be a valid module name/, fn -> Gen.Context.run(~w(Post posts title:string)) end assert_raise Mix.Error, ~r/The context and schema should have different names/, fn -> Gen.Context.run(~w(Blog Blog blogs)) end assert_raise Mix.Error, ~r/Cannot generate context Phoenix because it has the same name as the application/, fn -> Gen.Context.run(~w(Phoenix Post blogs)) end assert_raise Mix.Error, ~r/Cannot generate schema Phoenix because it has the same name as the application/, fn -> Gen.Context.run(~w(Blog Phoenix blogs)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Context.run(~w(Blog.Post posts)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Context.run(~w(Blog Post)) end end) end test "generates context and handles existing contexts", config do in_tmp_project(config.test, fn -> Gen.Context.run(~w(Blog Post posts slug:unique secret:redact title:string)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "field :title, :string" assert file =~ "field :secret, :string, redact: true" end) assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_post!" assert file =~ "def list_posts" assert file =~ "def create_post" assert file =~ "def update_post" assert file =~ "def delete_post" assert file =~ "def change_post" end) assert_file("test/phoenix/blog_test.exs", fn file -> assert file =~ "use Phoenix.DataCase" assert file =~ "describe \"posts\" do" assert file =~ "import Phoenix.BlogFixtures" end) assert_file("test/support/fixtures/blog_fixtures.ex", fn file -> assert file =~ "defmodule Phoenix.BlogFixtures do" assert file =~ "def post_fixture(attrs \\\\ %{})" assert file =~ "title: \"some title\"" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(path, fn file -> assert file =~ "create table(:posts)" assert file =~ "add :title, :string" assert file =~ "add :secret, :string" assert file =~ "create unique_index(:posts, [:slug])" end) send(self(), {:mix_shell_input, :yes?, true}) Gen.Context.run(~w(Blog Comment comments title:string)) assert_received {:mix_shell, :info, ["You are generating into an existing context" <> notice]} assert notice =~ "Phoenix.Blog context currently has 6 functions and 1 file in its directory" assert_received {:mix_shell, :yes?, ["Would you like to proceed?"]} assert_file("lib/phoenix/blog/comment.ex", fn file -> assert file =~ "field :title, :string" end) assert_file("test/phoenix/blog_test.exs", fn file -> assert file =~ "use Phoenix.DataCase" assert file =~ "describe \"comments\" do" assert file =~ "import Phoenix.BlogFixtures" end) assert_file("test/support/fixtures/blog_fixtures.ex", fn file -> assert file =~ "defmodule Phoenix.BlogFixtures do" assert file =~ "def comment_fixture(attrs \\\\ %{})" assert file =~ "title: \"some title\"" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_comments.exs") assert_file(path, fn file -> assert file =~ "create table(:comments)" assert file =~ "add :title, :string" end) assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_comment!" assert file =~ "def list_comments" assert file =~ "def create_comment" assert file =~ "def update_comment" assert file =~ "def delete_comment" assert file =~ "def change_comment" end) end) end test "generates with unique fields", config do in_tmp_project(config.test, fn -> Gen.Context.run(~w(Blog Post posts slug:string:unique subject:unique body:text:unique order:integer:unique price:decimal:unique published_at:utc_datetime:unique author:references:users:unique published?:boolean )) assert_received {:mix_shell, :info, [ """ Some of the generated database columns are unique. Please provide unique implementations for the following fixture function(s) in test/support/fixtures/blog_fixtures.ex: def unique_post_price do raise "implement the logic to generate a unique post price" end def unique_post_published_at do raise "implement the logic to generate a unique post published_at" end """ ]} assert_file("test/support/fixtures/blog_fixtures.ex", fn file -> assert file =~ ~S|def unique_post_order, do: System.unique_integer([:positive])| assert file =~ ~S|def unique_post_slug, do: "some slug#{System.unique_integer([:positive])}"| assert file =~ ~S|def unique_post_body, do: "some body#{System.unique_integer([:positive])}"| assert file =~ ~S|def unique_post_subject, do: "some subject#{System.unique_integer([:positive])}"| refute file =~ ~S|def unique_post_author| assert file =~ """ def unique_post_price do raise "implement the logic to generate a unique post price" end """ assert file =~ """ body: unique_post_body(), order: unique_post_order(), price: unique_post_price(), published?: true, published_at: unique_post_published_at(), slug: unique_post_slug(), subject: unique_post_subject() """ end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(path, fn file -> assert file =~ "create table(:posts)" assert file =~ "create unique_index(:posts, [:order])" assert file =~ "create unique_index(:posts, [:price])" assert file =~ "create unique_index(:posts, [:slug])" assert file =~ "create unique_index(:posts, [:subject])" end) end) end test "does not prompt on unimplemented functions with only string, text and integer unique fields", config do in_tmp_project(config.test, fn -> Gen.Context.run(~w(Blog Post posts slug:string:unique subject:unique body:text:unique order:integer:unique )) refute_received {:mix_shell, :info, ["\nSome of the generated database columns are unique." <> _]} end) end test "generates into existing context without prompt with --merge-with-existing-context", config do in_tmp_project(config.test, fn -> Gen.Context.run(~w(Blog Post posts title)) assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_post!" assert file =~ "def list_posts" assert file =~ "def create_post" assert file =~ "def update_post" assert file =~ "def delete_post" assert file =~ "def change_post" end) Gen.Context.run(~w(Blog Comment comments message:string --merge-with-existing-context)) refute_received {:mix_shell, :info, ["You are generating into an existing context" <> _notice]} assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_comment!" assert file =~ "def list_comments" assert file =~ "def create_comment" assert file =~ "def update_comment" assert file =~ "def delete_comment" assert file =~ "def change_comment" end) end) end test "when more than 50 attributes are given", config do in_tmp_project(config.test, fn -> long_attribute_list = Enum.map_join(0..55, " ", &"attribute#{&1}:string") Gen.Context.run(~w(Blog Post posts title #{long_attribute_list})) assert_file("test/phoenix/blog_test.exs", fn file -> refute file =~ "...}" end) end) end test "generates schema with no migration option", config do in_tmp_project(config.test, fn -> Gen.Context.run(~w(Blog Post posts title:string --no-migration)) assert Path.wildcard("priv/repo/migrations/*") == [] end) end test "generates context with no schema and repo option", config do in_tmp_project(config.test, fn -> Gen.Context.run(~w(Blog Post posts title:string --no-schema --repo=Foo.RepoX)) refute_file("lib/phoenix/blog/post.ex") assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "alias Foo.RepoX, as: Repo" assert file =~ "def get_post!" assert file =~ "def list_posts" assert file =~ "def create_post" assert file =~ "def update_post" assert file =~ "def delete_post" assert file =~ "def change_post" assert file =~ "raise \"TODO\"" end) assert_file("test/phoenix/blog_test.exs", fn file -> assert file =~ "use Phoenix.DataCase" assert file =~ "describe \"posts\" do" assert file =~ "import Phoenix.BlogFixtures" end) assert_file("test/support/fixtures/blog_fixtures.ex", fn file -> assert file =~ "defmodule Phoenix.BlogFixtures do" assert file =~ "def post_fixture(attrs \\\\ %{})" assert file =~ "title: \"some title\"" end) assert Path.wildcard("priv/repo/migrations/*_create_posts.exs") == [] end) end test "generates context with enum", config do in_tmp_project(config.test, fn -> Gen.Context.run( ~w(Accounts User users email:text:unique password:text:redact status:enum:verified:unverified:disabled) ) assert_file("lib/phoenix/accounts/user.ex", fn file -> assert file =~ "field :status, Ecto.Enum, values: [:verified, :unverified, :disabled]" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_users.exs") assert_file(path, fn file -> assert file =~ "create table(:users)" assert file =~ "add :status, :string" end) end) end test "generates scoped context", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :binary_id, schema_table: :users, test_data_fixture: MyApp.AccountsFixtures, test_setup_helper: :register_and_log_in_user ] ], fn -> Gen.Context.run(~w(Blog Post posts title:string)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "field :title, :string" assert file =~ "field :user_id, :binary_id" end) assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def subscribe_posts(%Scope{} = scope)" assert file =~ "defp broadcast_post(%Scope{} = scope, message)" assert file =~ "def get_post!(%Scope{} = scope, id)" assert file =~ "def list_posts(%Scope{} = scope)" assert file =~ "def create_post(%Scope{} = scope, attrs)" assert file =~ "def update_post(%Scope{} = scope, %Post{} = post, attrs)" assert file =~ "def delete_post(%Scope{} = scope, %Post{} = post)" assert file =~ "def change_post(%Scope{} = scope, %Post{} = post, attrs \\\\ %{})" end) assert_file("test/phoenix/blog_test.exs", fn file -> assert file =~ "use Phoenix.DataCase" assert file =~ "describe \"posts\" do" assert file =~ "import Phoenix.BlogFixtures" end) assert_file("test/support/fixtures/blog_fixtures.ex", fn file -> assert file =~ "defmodule Phoenix.BlogFixtures do" assert file =~ "def post_fixture(scope, attrs \\\\ %{})" assert file =~ "title: \"some title\"" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(path, fn file -> assert file =~ "create table(:posts)" assert file =~ "add :title, :string" assert file =~ "add :user_id, references(:users, type: :binary_id, on_delete: :delete_all)" end) end ) end) end test "raises when a reference conflicts with the scope", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :binary_id, schema_table: :users ] ], fn -> assert_raise Mix.Error, ~r"Reference :user_id has the same name as the scope schema key, either skip the reference or pass it with the --no-scope flag.", fn -> Gen.Context.run( ~w(Blog Post posts title:string user_id:references:users) ) end end ) end) end end ================================================ FILE: test/mix/tasks/phx.gen.embedded_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.Gen.EmbeddedTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen alias Mix.Phoenix.Schema setup do Mix.Task.clear() :ok end test "build" do in_tmp_project("embedded build", fn -> schema = Gen.Embedded.build(~w(Blog.Post title:string)) assert %Schema{ alias: Post, module: Phoenix.Blog.Post, repo: Phoenix.Repo, migration?: false, migration_defaults: %{title: ""}, plural: nil, singular: "post", human_plural: "Nil", human_singular: "Post", attrs: [title: :string], types: [title: :string], embedded?: true, defaults: %{title: ""} } = schema assert String.ends_with?(schema.file, "lib/phoenix/blog/post.ex") end) end test "generates embedded schema", config do in_tmp_project(config.test, fn -> Gen.Embedded.run(~w(Blog.Post title:string)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "embedded_schema do" end) end) end test "generates nested embedded schema", config do in_tmp_project(config.test, fn -> Gen.Embedded.run(~w(Blog.Admin.User name:string)) assert_file("lib/phoenix/blog/admin/user.ex", fn file -> assert file =~ "defmodule Phoenix.Blog.Admin.User do" assert file =~ "embedded_schema do" end) end) end test "generates embedded schema with proper datetime types", config do in_tmp_project(config.test, fn -> Gen.Embedded.run( ~w(Blog.Comment title:string drafted_at:datetime published_at:naive_datetime edited_at:utc_datetime) ) assert_file("lib/phoenix/blog/comment.ex", fn file -> assert file =~ "field :drafted_at, :naive_datetime" assert file =~ "field :published_at, :naive_datetime" assert file =~ "field :edited_at, :utc_datetime" end) end) end test "generates embedded schema with enum", config do in_tmp_project(config.test, fn -> Gen.Embedded.run( ~w(Blog.Comment comments title:string status:enum:unpublished:published:deleted) ) assert_file("lib/phoenix/blog/comment.ex", fn file -> assert file =~ "field :status, Ecto.Enum, values: [:unpublished, :published, :deleted]" end) end) end test "generates embedded schema with redact option", config do in_tmp_project(config.test, fn -> Gen.Embedded.run(~w(Blog.Comment comments title:string secret:redact)) assert_file("lib/phoenix/blog/comment.ex", fn file -> assert file =~ "field :secret, :string, redact: true" end) end) end test "generates embedded schema with references", config do in_tmp_project(config.test, fn -> Gen.Embedded.run( ~w(Blog.Comment comments body word_count:integer author_id:references:author) ) assert_file("lib/phoenix/blog/comment.ex", fn file -> assert file =~ "field :author_id, :id" assert file =~ "field :body, :string" assert file =~ "field :word_count, :integer" end) end) end end ================================================ FILE: test/mix/tasks/phx.gen.html_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.Gen.HtmlTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen setup do Mix.Task.clear() :ok end test "invalid mix arguments", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/Expected the context, "blog", to be a valid module name/, fn -> Gen.Html.run(~w(blog Post posts title:string)) end assert_raise Mix.Error, ~r/The context and schema should have different names/, fn -> Gen.Html.run(~w(Blog Blog blogs)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Html.run(~w(Blog.Post posts)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Html.run(~w(Blog Post)) end assert_raise Mix.Error, ~r/Enum type requires at least one value/, fn -> Gen.Html.run(~w(Blog Post posts status:enum)) end assert_raise Mix.Error, ~r/requires at least one attribute/, fn -> Gen.Html.run(~w(Blog Post posts)) end end) end test "generates html resource and handles existing contexts", config do one_day_in_seconds = 24 * 3600 naive_datetime = %{NaiveDateTime.utc_now() | second: 0, microsecond: {0, 6}} datetime = %{DateTime.utc_now() | second: 0, microsecond: {0, 6}} in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Post posts title content:text slug:unique votes:integer cost:decimal tags:array:text popular:boolean drafted_at:datetime status:enum:unpublished:published:deleted published_at:utc_datetime published_at_usec:utc_datetime_usec deleted_at:naive_datetime deleted_at_usec:naive_datetime_usec alarm:time alarm_usec:time_usec secret:uuid:redact announcement_date:date alarm:time metadata:map weight:float user_id:references:users )) assert_file("lib/phoenix/blog/post.ex") assert_file("lib/phoenix/blog.ex") assert_file("test/phoenix/blog_test.exs", fn file -> assert file =~ "alarm: ~T[15:01:01]" assert file =~ "alarm_usec: ~T[15:01:01.000000]" assert file =~ "announcement_date: #{Date.utc_today() |> Date.add(-1) |> inspect()}" assert file =~ "deleted_at: #{naive_datetime |> NaiveDateTime.add(-one_day_in_seconds) |> NaiveDateTime.truncate(:second) |> inspect()}" assert file =~ "deleted_at_usec: #{naive_datetime |> NaiveDateTime.add(-one_day_in_seconds) |> inspect()}" assert file =~ "cost: \"120.5\"" assert file =~ "published_at: #{datetime |> DateTime.add(-one_day_in_seconds) |> DateTime.truncate(:second) |> inspect()}" assert file =~ "published_at_usec: #{datetime |> DateTime.add(-one_day_in_seconds) |> inspect()}" assert file =~ "weight: 120.5" assert file =~ "status: :published" assert file =~ "assert post.announcement_date == #{inspect(Date.utc_today())}" assert file =~ "assert post.deleted_at == #{naive_datetime |> NaiveDateTime.truncate(:second) |> inspect()}" assert file =~ "assert post.deleted_at_usec == #{inspect(naive_datetime)}" assert file =~ "assert post.published_at == #{datetime |> DateTime.truncate(:second) |> inspect()}" assert file =~ "assert post.published_at_usec == #{inspect(datetime)}" assert file =~ "assert post.alarm == ~T[15:01:01]" assert file =~ "assert post.alarm_usec == ~T[15:01:01.000000]" assert file =~ "assert post.cost == Decimal.new(\"120.5\")" assert file =~ "assert post.weight == 120.5" assert file =~ "assert post.status == :published" end) assert_file("test/phoenix_web/controllers/post_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.PostControllerTest" assert file =~ ~s|~p"/posts| end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(path, fn file -> assert file =~ "create table(:posts)" assert file =~ "add :title, :string" assert file =~ "add :content, :text" assert file =~ "add :status, :string" assert file =~ "create unique_index(:posts, [:slug])" end) assert_file("lib/phoenix_web/controllers/post_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostController" assert file =~ "use PhoenixWeb, :controller" assert file =~ "Blog.get_post!" assert file =~ "Blog.list_posts" assert file =~ "Blog.create_post" assert file =~ "Blog.update_post" assert file =~ "Blog.delete_post" assert file =~ "Blog.change_post" assert file =~ ~s|redirect(to: ~p"/posts| end) assert_file("lib/phoenix_web/controllers/post_html.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostHTML" end) assert_file("lib/phoenix_web/controllers/post_html/index.html.heex", fn file -> assert file =~ ~s|~p"/posts| end) assert_file("lib/phoenix_web/controllers/post_html/new.html.heex", fn file -> assert file =~ ~S(action={~p"/posts"}) end) assert_file("lib/phoenix_web/controllers/post_html/post_form.html.heex") assert_file("lib/phoenix_web/controllers/post_html/show.html.heex", fn file -> assert file =~ ~s|~p"/posts| end) assert_file("lib/phoenix_web/controllers/post_html/edit.html.heex", fn file -> assert file =~ ~S(action={~p"/posts/#{@post}"}) end) assert_file("lib/phoenix_web/controllers/post_html/post_form.html.heex", fn file -> assert file =~ ~S(<.form :let={f} for={@changeset} action={@action}>) assert file =~ ~s(<.input field={f[:title]} type="text") assert file =~ ~s(<.input field={f[:content]} type="textarea") assert file =~ ~s(<.input field={f[:votes]} type="number") assert file =~ ~s(<.input field={f[:cost]} type="number" label="Cost" step="any") assert file =~ """ <.input field={f[:tags]} type="select" multiple """ assert file =~ ~s(<.input field={f[:popular]} type="checkbox") assert file =~ ~s(<.input field={f[:drafted_at]} type="datetime-local") assert file =~ ~s(<.input field={f[:published_at]} type="datetime-local") assert file =~ ~s(<.input field={f[:deleted_at]} type="datetime-local") assert file =~ ~s(<.input field={f[:announcement_date]} type="date") assert file =~ ~s(<.input field={f[:alarm]} type="time") assert file =~ ~s(<.input field={f[:secret]} type="text" label="Secret" />) refute file =~ ~s(field={f[:metadata]}) assert file =~ """ <.input field={f[:status]} type="select" """ assert file =~ ~s|Ecto.Enum.values(Phoenix.Blog.Post, :status)| refute file =~ ~s(<.input field={f[:user_id]}) end) send(self(), {:mix_shell_input, :yes?, true}) Gen.Html.run(~w(Blog Comment comments title:string)) assert_received {:mix_shell, :info, ["You are generating into an existing context" <> _]} assert_file("lib/phoenix/blog/comment.ex") assert_file("test/phoenix_web/controllers/comment_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentControllerTest" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_comments.exs") assert_file(path, fn file -> assert file =~ "create table(:comments)" assert file =~ "add :title, :string" end) assert_file("lib/phoenix_web/controllers/comment_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentController" assert file =~ "use PhoenixWeb, :controller" assert file =~ "Blog.get_comment!" assert file =~ "Blog.list_comments" assert file =~ "Blog.create_comment" assert file =~ "Blog.update_comment" assert file =~ "Blog.delete_comment" assert file =~ "Blog.change_comment" assert file =~ ~s|redirect(to: ~p"/comments| end) assert_receive {:mix_shell, :info, [ """ Add the resource to your browser scope in lib/phoenix_web/router.ex: resources "/posts", PostController """ ]} end) end test "generates without explicit context", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Post posts title content:text slug:unique votes:integer cost:decimal tags:array:text popular:boolean drafted_at:datetime status:enum:unpublished:published:deleted published_at:utc_datetime published_at_usec:utc_datetime_usec deleted_at:naive_datetime deleted_at_usec:naive_datetime_usec alarm:time alarm_usec:time_usec secret:uuid:redact announcement_date:date alarm:time metadata:map weight:float user_id:references:users )) assert_file("lib/phoenix/posts/post.ex") assert_file("lib/phoenix/posts.ex") assert_file("test/phoenix/posts_test.exs", fn file -> assert file =~ "alarm: ~T[15:01:01]" assert file =~ "alarm_usec: ~T[15:01:01.000000]" assert file =~ "announcement_date: #{Date.utc_today() |> Date.add(-1) |> inspect()}" end) end) end test "generates into existing context without prompt with --merge-with-existing-context", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Post posts title)) assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_post!" assert file =~ "def list_posts" assert file =~ "def create_post" assert file =~ "def update_post" assert file =~ "def delete_post" assert file =~ "def change_post" end) Gen.Html.run(~w(Blog Comment comments message:string --merge-with-existing-context)) refute_received {:mix_shell, :info, ["You are generating into an existing context" <> _notice]} assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_comment!" assert file =~ "def list_comments" assert file =~ "def create_comment" assert file =~ "def update_comment" assert file =~ "def delete_comment" assert file =~ "def change_comment" end) end) end test "with --web namespace generates namespaced web modules and directories", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Post posts title:string --web Blog)) assert_file("test/phoenix_web/controllers/blog/post_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostControllerTest" assert file =~ ~s|~p"/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostController" assert file =~ "use PhoenixWeb, :controller" assert file =~ ~s|redirect(to: ~p"/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_html/edit.html.heex", fn file -> assert file =~ ~s|~p"/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_html/index.html.heex", fn file -> assert file =~ ~s|~p"/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_html/new.html.heex", fn file -> assert file =~ ~s|~p"/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_html/show.html.heex", fn file -> assert file =~ ~s|~p"/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_html.ex", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostHTML" end) assert_receive {:mix_shell, :info, [ """ Add the resource to your Blog :browser scope in lib/phoenix_web/router.ex: scope "/blog", PhoenixWeb.Blog do pipe_through :browser ... resources "/posts", PostController end """ ]} end) end test "with --no-context skips context and schema file generation", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Comment comments title:string --no-context)) refute_file("lib/phoenix/blog.ex") refute_file("lib/phoenix/blog/comment.ex") assert Path.wildcard("priv/repo/migrations/*.exs") == [] assert_file("test/phoenix_web/controllers/comment_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentControllerTest" end) assert_file("lib/phoenix_web/controllers/comment_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/comment_html.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentHTML" end) end) end test "with a matching plural and singular term", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Tracker Series series value:integer)) assert_file("lib/phoenix_web/controllers/series_controller.ex", fn file -> assert file =~ "render(conn, :index, series_collection: series)" end) end) end test "with --no-context no warning is emitted when context exists", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Post posts title:string)) assert_file("lib/phoenix/blog.ex") assert_file("lib/phoenix/blog/post.ex") Gen.Html.run(~w(Blog Comment comments title:string --no-context)) refute_received {:mix_shell, :info, ["You are generating into an existing context" <> _]} assert_file("test/phoenix_web/controllers/comment_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentControllerTest" end) assert_file("lib/phoenix_web/controllers/comment_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/comment_html.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentHTML" end) end) end test "with --no-schema skips schema file generation", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Comment comments title:string --no-schema)) assert_file("lib/phoenix/blog.ex") refute_file("lib/phoenix/blog/comment.ex") assert Path.wildcard("priv/repo/migrations/*.exs") == [] assert_file("test/phoenix_web/controllers/comment_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentControllerTest" end) assert_file("lib/phoenix_web/controllers/comment_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/comment_html.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentHTML" end) end) end test "when more than 50 arguments are given", config do in_tmp_project(config.test, fn -> long_attribute_list = Enum.map_join(0..55, " ", &"attribute#{&1}:string") Gen.Html.run(~w(Blog Post posts #{long_attribute_list})) assert_file("test/phoenix_web/controllers/post_controller_test.exs", fn file -> refute file =~ "...}" end) end) end test "with custom primary key", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Post posts title:string --primary-key post_id)) assert_file("lib/phoenix_web/controllers/post_controller.ex", fn file -> assert file =~ ~s[%{"post_id" => post_id}] assert file =~ ~s[%{"post_id" => post_id, "post" => post_params}] assert file =~ ~s[Blog.get_post!(post_id)] end) assert_file("lib/phoenix_web/controllers/post_html/show.html.heex", fn file -> assert file =~ ~S(Post {@post.post_id}) end) assert_file("lib/phoenix_web/controllers/post_html/edit.html.heex", fn file -> assert file =~ ~S(Edit Post {@post.post_id}) end) end) end describe "inside umbrella" do test "without context_app generators config uses web dir", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: nil) Gen.Html.run(~w(Accounts User users name:string)) assert_file("lib/phoenix/accounts.ex") assert_file("lib/phoenix/accounts/user.ex") assert_file("lib/phoenix_web/controllers/user_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.UserController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/user_html.ex", fn file -> assert file =~ "defmodule PhoenixWeb.UserHTML" end) assert_file("test/phoenix_web/controllers/user_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.UserControllerTest" end) end) end test "raises with false context_app", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: false) assert_raise Mix.Error, ~r/no context_app configured/, fn -> Gen.Html.run(~w(Accounts User users name:string)) end end) end test "with context_app generators config does not use web dir", config do in_tmp_umbrella_project(config.test, fn -> File.mkdir!("another_app") Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) Gen.Html.run(~w(Accounts User users name:string)) assert_file("another_app/lib/another_app/accounts.ex") assert_file("another_app/lib/another_app/accounts/user.ex") assert_file("lib/phoenix/controllers/user_controller.ex", fn file -> assert file =~ "defmodule Phoenix.UserController" assert file =~ "use Phoenix, :controller" end) assert_file("lib/phoenix/controllers/user_html.ex", fn file -> assert file =~ "defmodule Phoenix.UserHTML" end) assert_file("test/phoenix/controllers/user_controller_test.exs", fn file -> assert file =~ "defmodule Phoenix.UserControllerTest" end) end) end test "allows enum type with at least one value", config do in_tmp_project(config.test, fn -> Gen.Html.run(~w(Blog Post posts status:enum:new)) assert_file("lib/phoenix_web/controllers/post_html/post_form.html.heex", fn file -> assert file =~ ~s|Ecto.Enum.values(Phoenix.Blog.Post, :status)| end) end) end test "respect route_prefix in scopes", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ organization: [ module: Phoenix.Organizations.Scope, assign_key: :current_organization, access_path: [:organization, :id], route_access_path: [:organization, :slug], route_prefix: "/orgs/:slug" ] ], fn -> Gen.Html.run(~w(Blog Post posts title:string --scope organization)) assert_file("lib/phoenix_web/controllers/post_controller.ex", fn file -> assert file =~ ~s|redirect(to: ~p"/orgs/\#{conn.assigns.current_organization.organization.slug}/posts| end) assert_file("lib/phoenix_web/controllers/post_html/index.html.heex", fn file -> assert file =~ ~s|href={~p"/orgs/\#{@current_organization.organization.slug}/posts/new"| assert file =~ ~s|navigate={~p"/orgs/\#{@current_organization.organization.slug}/posts/| end) assert_file("lib/phoenix_web/controllers/post_html/show.html.heex", fn file -> assert file =~ ~s|navigate={~p"/orgs/\#{@current_organization.organization.slug}/posts"| end) assert_file("lib/phoenix_web/controllers/post_html/edit.html.heex", fn file -> assert file =~ ~s|action={~p"/orgs/\#{@current_organization.organization.slug}/posts/\#{@post}"| end) assert_file("lib/phoenix_web/controllers/post_html/new.html.heex", fn file -> assert file =~ ~s|action={~p"/orgs/\#{@current_organization.organization.slug}/posts"| end) assert_file("test/phoenix_web/controllers/post_controller_test.exs", fn file -> assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts"| assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts/new"| assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts/\#{post}"| assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts/\#{post}/edit"| end) end ) end) end end end ================================================ FILE: test/mix/tasks/phx.gen.json_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.Gen.JsonTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen setup do Mix.Task.clear() :ok end test "invalid mix arguments", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/Expected the context, "blog", to be a valid module name/, fn -> Gen.Json.run(~w(blog Post posts title:string)) end assert_raise Mix.Error, ~r/The context and schema should have different names/, fn -> Gen.Json.run(~w(Blog Blog blogs)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Json.run(~w(Blog.Post posts)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Json.run(~w(Blog Post)) end assert_raise Mix.Error, ~r/requires at least one attribute/, fn -> Gen.Json.run(~w(Blog Post posts)) end end) end test "generates json resource", config do one_day_in_seconds = 24 * 3600 naive_datetime = %{NaiveDateTime.utc_now() | second: 0, microsecond: {0, 6}} |> NaiveDateTime.add(-one_day_in_seconds) datetime = %{DateTime.utc_now() | second: 0, microsecond: {0, 6}} |> DateTime.add(-one_day_in_seconds) in_tmp_project(config.test, fn -> Gen.Json.run(~w(Blog Post posts title slug:unique votes:integer cost:decimal tags:array:text popular:boolean drafted_at:datetime params:map published_at:utc_datetime published_at_usec:utc_datetime_usec deleted_at:naive_datetime deleted_at_usec:naive_datetime_usec alarm:time alarm_usec:time_usec secret:uuid:redact announcement_date:date weight:float user_id:references:users )) assert_file("lib/phoenix/blog/post.ex") assert_file("lib/phoenix/blog.ex") assert_file("test/phoenix/blog_test.exs", fn file -> assert file =~ "use Phoenix.DataCase" end) assert_file("test/phoenix_web/controllers/post_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.PostControllerTest" assert file =~ """ assert %{ "id" => ^id, "alarm" => "14:00:00", "alarm_usec" => "14:00:00.000000", "announcement_date" => "#{Date.add(Date.utc_today(), -1)}", "cost" => "120.5", "deleted_at" => "#{naive_datetime |> NaiveDateTime.truncate(:second) |> NaiveDateTime.to_iso8601()}", "deleted_at_usec" => "#{NaiveDateTime.to_iso8601(naive_datetime)}", "drafted_at" => "#{datetime |> NaiveDateTime.truncate(:second) |> NaiveDateTime.to_iso8601()}", "params" => %{}, "popular" => true, "published_at" => "#{datetime |> DateTime.truncate(:second) |> DateTime.to_iso8601()}", "published_at_usec" => "#{DateTime.to_iso8601(datetime)}", "secret" => "7488a646-e31f-11e4-aace-600308960662", "slug" => "some slug", "tags" => [], "title" => "some title", "votes" => 42, "weight" => 120.5 } = json_response(conn, 200)["data"] """ end) assert [_] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file("lib/phoenix_web/controllers/fallback_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.FallbackController" end) assert_file("lib/phoenix_web/controllers/post_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostController" assert file =~ "use PhoenixWeb, :controller" assert file =~ "Blog.get_post!" assert file =~ "Blog.list_posts" assert file =~ "Blog.create_post" assert file =~ "Blog.update_post" assert file =~ "Blog.delete_post" assert file =~ ~s|~p"/api/posts| end) assert_receive {:mix_shell, :info, [ """ Add the resource to the "/api" scope in lib/phoenix_web/router.ex: resources "/posts", PostController, except: [:new, :edit] """ ]} end) end test "generates without explicit context", config do in_tmp_project(config.test, fn -> Gen.Json.run(~w(Post posts title slug:unique votes:integer cost:decimal tags:array:text popular:boolean drafted_at:datetime params:map published_at:utc_datetime published_at_usec:utc_datetime_usec deleted_at:naive_datetime deleted_at_usec:naive_datetime_usec alarm:time alarm_usec:time_usec secret:uuid:redact announcement_date:date weight:float user_id:references:users )) assert_file("lib/phoenix/posts/post.ex") assert_file("lib/phoenix/posts.ex") assert_file("test/phoenix/posts_test.exs", fn file -> assert file =~ "use Phoenix.DataCase" end) assert_file("lib/phoenix_web/controllers/post_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostController" assert file =~ "use PhoenixWeb, :controller" assert file =~ "Posts.get_post!" assert file =~ "Posts.list_posts" assert file =~ "Posts.create_post" assert file =~ "Posts.update_post" assert file =~ "Posts.delete_post" assert file =~ ~s|~p"/api/posts| end) end) end test "generates into existing context without prompt with --merge-with-existing-context", config do in_tmp_project(config.test, fn -> Gen.Json.run(~w(Blog Post posts title)) assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_post!" assert file =~ "def list_posts" assert file =~ "def create_post" assert file =~ "def update_post" assert file =~ "def delete_post" assert file =~ "def change_post" end) Gen.Json.run(~w(Blog Comment comments message:string --merge-with-existing-context)) refute_received {:mix_shell, :info, ["You are generating into an existing context" <> _notice]} assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_comment!" assert file =~ "def list_comments" assert file =~ "def create_comment" assert file =~ "def update_comment" assert file =~ "def delete_comment" assert file =~ "def change_comment" end) end) end test "when more than 50 arguments are given", config do in_tmp_project(config.test, fn -> long_attribute_list = Enum.map_join(0..55, " ", &"attribute#{&1}:string") Gen.Json.run(~w(Blog Post posts #{long_attribute_list})) assert_file("test/phoenix_web/controllers/post_controller_test.exs", fn file -> refute file =~ "...}" end) end) end test "with json --web namespace generates namespaced web modules and directories", config do in_tmp_project(config.test, fn -> Gen.Json.run(~w(Blog Post posts title:string --web Blog)) assert_file("test/phoenix_web/controllers/blog/post_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostControllerTest" assert file =~ ~s|~p"/api/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostController" assert file =~ "use PhoenixWeb, :controller" assert file =~ ~s|~p"/api/blog/posts| end) assert_file("lib/phoenix_web/controllers/blog/post_json.ex", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostJSON" end) assert_file("lib/phoenix_web/controllers/changeset_json.ex", fn file -> assert file =~ "Ecto.Changeset.traverse_errors(changeset, &translate_error/1)" end) assert_receive {:mix_shell, :info, [ """ Add the resource to your Blog :api scope in lib/phoenix_web/router.ex: scope "/blog", PhoenixWeb.Blog do pipe_through :api ... resources "/posts", PostController end """ ]} end) end test "with --no-context skips context and schema file generation", config do in_tmp_project(config.test, fn -> Gen.Json.run(~w(Blog Comment comments title:string --no-context)) refute_file("lib/phoenix/blog.ex") refute_file("lib/phoenix/blog/comment.ex") assert Path.wildcard("priv/repo/migrations/*.exs") == [] assert_file("test/phoenix_web/controllers/comment_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentControllerTest" end) assert_file("lib/phoenix_web/controllers/comment_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/comment_json.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentJSON" end) end) end test "with --no-context no warning is emitted when context exists", config do in_tmp_project(config.test, fn -> Gen.Json.run(~w(Blog Post posts title:string)) assert_file("lib/phoenix/blog.ex") assert_file("lib/phoenix/blog/post.ex") Gen.Json.run(~w(Blog Comment comments title:string --no-context)) refute_received {:mix_shell, :info, ["You are generating into an existing context" <> _]} assert_file("test/phoenix_web/controllers/comment_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentControllerTest" end) assert_file("lib/phoenix_web/controllers/comment_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/comment_json.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentJSON" end) end) end test "with --no-schema skips schema file generation", config do in_tmp_project(config.test, fn -> Gen.Json.run(~w(Blog Comment comments title:string --no-schema)) assert_file("lib/phoenix/blog.ex") refute_file("lib/phoenix/blog/comment.ex") assert Path.wildcard("priv/repo/migrations/*.exs") == [] assert_file("test/phoenix_web/controllers/comment_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentControllerTest" end) assert_file("lib/phoenix_web/controllers/comment_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/comment_json.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentJSON" end) end) end describe "inside umbrella" do test "without context_app generators config uses web dir", config do in_tmp_umbrella_project(config.test, fn -> Gen.Json.run(~w(Accounts User users name:string)) assert_file("lib/phoenix/accounts.ex") assert_file("lib/phoenix/accounts/user.ex") assert_file("lib/phoenix_web/controllers/user_controller.ex", fn file -> assert file =~ "defmodule PhoenixWeb.UserController" assert file =~ "use PhoenixWeb, :controller" end) assert_file("lib/phoenix_web/controllers/user_json.ex", fn file -> assert file =~ "defmodule PhoenixWeb.UserJSON" end) assert_file("test/phoenix_web/controllers/user_controller_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.UserControllerTest" end) end) end test "raises with false context_app", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: false) assert_raise Mix.Error, ~r/no context_app configured/, fn -> Gen.Json.run(~w(Accounts User users name:string)) end end) end test "with context_app generators config does not use web dir", config do in_tmp_umbrella_project(config.test, fn -> File.mkdir!("another_app") Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) Gen.Json.run(~w(Accounts User users name:string)) assert_file("another_app/lib/another_app/accounts.ex") assert_file("another_app/lib/another_app/accounts/user.ex") assert_file("lib/phoenix/controllers/user_controller.ex", fn file -> assert file =~ "defmodule Phoenix.UserController" assert file =~ "use Phoenix, :controller" end) assert_file("lib/phoenix/controllers/user_json.ex", fn file -> assert file =~ "defmodule Phoenix.UserJSON" end) assert_file("test/phoenix/controllers/user_controller_test.exs", fn file -> assert file =~ "defmodule Phoenix.UserControllerTest" end) end) end end test "with existing core_components.ex file", config do in_tmp_project(config.test, fn -> File.mkdir_p!("lib/phoenix_web/components") File.write!("lib/phoenix_web/components/core_components.ex", """ defmodule PhoenixWeb.CoreComponents do end """) [{module, _}] = Code.compile_file("lib/phoenix_web/components/core_components.ex") Gen.Json.run(~w(Blog Post posts title:string --web Blog)) assert_file("lib/phoenix_web/controllers/changeset_json.ex", fn file -> assert file =~ "Ecto.Changeset.traverse_errors(changeset, &PhoenixWeb.CoreComponents.translate_error/1)" end) # Clean up test case specific compile artifact so it doesn't leak to other test cases :code.purge(module) :code.delete(module) end) end test "with custom primary key", config do in_tmp_project(config.test, fn -> Gen.Json.run(~w(Blog Post posts title:string --primary-key post_id)) assert_file("lib/phoenix_web/controllers/post_controller.ex", fn file -> refute file =~ ~s[%{"id" =>] assert file =~ ~s[%{"post_id" =>] assert file =~ "Blog.get_post!(post_id)" end) assert_file("lib/phoenix_web/controllers/post_json.ex", fn file -> assert file =~ "post_id: post.post_id," end) assert_file("test/phoenix_web/controllers/post_controller_test.exs", fn file -> assert file =~ ~s["post_id" => ^post_id,] end) end) end test "respect route_prefix in scopes", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ organization: [ module: Phoenix.Organizations.Scope, assign_key: :current_organization, access_path: [:organization, :id], route_access_path: [:organization, :slug], route_prefix: "/orgs/:slug" ] ], fn -> Gen.Json.run(~w(Blog Post posts title:string --scope organization)) assert_file("lib/phoenix_web/controllers/post_controller.ex", fn file -> assert file =~ ~s|~p"/api/orgs/\#{conn.assigns.current_organization.organization.slug}/posts| end) assert_file("test/phoenix_web/controllers/post_controller_test.exs", fn file -> assert file =~ ~s|~p"/api/orgs/\#{scope.organization.slug}/posts"| assert file =~ ~s|~p"/api/orgs/\#{scope.organization.slug}/posts/\#{post}"| end) end ) end) end end ================================================ FILE: test/mix/tasks/phx.gen.live_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.Gen.LiveTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen setup do Mix.Task.clear() :ok end defp in_tmp_live_project(test, func) do in_tmp_project(test, fn -> File.mkdir_p!("lib") File.touch!("lib/phoenix_web.ex") File.touch!("lib/phoenix.ex") func.() end) end defp in_tmp_live_umbrella_project(test, func) do in_tmp_umbrella_project(test, fn -> File.mkdir_p!("phoenix/lib") File.mkdir_p!("phoenix_web/lib") File.touch!("phoenix/lib/phoenix.ex") File.touch!("phoenix_web/lib/phoenix_web.ex") func.() end) end test "components are in sync with installer" do assert File.read!("priv/templates/phx.gen.live/core_components.ex.eex") == File.read!("installer/templates/phx_web/components/core_components.ex.eex") end test "invalid mix arguments", config do in_tmp_live_project(config.test, fn -> assert_raise Mix.Error, ~r/Expected the context, "blog", to be a valid module name/, fn -> Gen.Live.run(~w(blog Post posts title:string)) end assert_raise Mix.Error, ~r/The context and schema should have different names/, fn -> Gen.Live.run(~w(Blog Blog blogs)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Live.run(~w(Blog.Post posts)) end assert_raise Mix.Error, ~r/Invalid arguments/, fn -> Gen.Live.run(~w(Blog Post)) end assert_raise Mix.Error, ~r/requires at least one attribute/, fn -> Gen.Live.run(~w(Blog Post posts)) end end) end test "generates live resource and handles existing contexts", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Blog Post posts title content:text slug:unique votes:integer cost:decimal tags:array:text popular:boolean drafted_at:datetime status:enum:unpublished:published:deleted published_at:utc_datetime published_at_usec:utc_datetime_usec deleted_at:naive_datetime deleted_at_usec:naive_datetime_usec alarm:time alarm_usec:time_usec secret:uuid:redact announcement_date:date alarm:time metadata:map weight:float user_id:references:users )) assert_file("lib/phoenix/blog/post.ex") assert_file("lib/phoenix/blog.ex") assert_file("test/phoenix/blog_test.exs") assert_file("lib/phoenix_web/live/post_live/index.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostLive.Index" refute file =~ "dom_id:" end) assert_file("lib/phoenix_web/live/post_live/show.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostLive.Show" end) assert_file("lib/phoenix_web/live/post_live/form.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostLive.Form" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(path, fn file -> assert file =~ "create table(:posts)" assert file =~ "add :title, :string" assert file =~ "add :content, :text" assert file =~ "create unique_index(:posts, [:slug])" end) assert_file("lib/phoenix_web/live/post_live/index.ex", fn file -> assert file =~ ~S|~p"/posts/#{post}"| end) assert_file("lib/phoenix_web/live/post_live/show.ex", fn file -> assert file =~ ~S|~p"/posts"| end) assert_file("lib/phoenix_web/live/post_live/form.ex", fn file -> assert file =~ ~s(<.form) assert file =~ ~s(<.input field={@form[:title]} type="text") assert file =~ ~s(<.input field={@form[:content]} type="textarea") assert file =~ ~s(<.input field={@form[:votes]} type="number") assert file =~ ~s(<.input field={@form[:cost]} type="number" label="Cost" step="any") assert file =~ """ <.input field={@form[:tags]} type="select" multiple """ assert file =~ ~s(<.input field={@form[:popular]} type="checkbox") assert file =~ ~s(<.input field={@form[:drafted_at]} type="datetime-local") assert file =~ ~s(<.input field={@form[:published_at]} type="datetime-local") assert file =~ ~s(<.input field={@form[:deleted_at]} type="datetime-local") assert file =~ ~s(<.input field={@form[:announcement_date]} type="date") assert file =~ ~s(<.input field={@form[:alarm]} type="time") assert file =~ ~s(<.input field={@form[:secret]} type="text" label="Secret" />) refute file =~ ~s( assert file =~ ~r"@invalid_attrs.*popular: false" assert file =~ ~S|~p"/posts"| assert file =~ ~S|~p"/posts/new"| assert file =~ ~S|~p"/posts/#{post}"| assert file =~ ~S|~p"/posts/#{post}/edit"| end) send(self(), {:mix_shell_input, :yes?, true}) Gen.Live.run(~w(Blog Comment comments title:string)) assert_received {:mix_shell, :info, ["You are generating into an existing context" <> _]} assert_file("lib/phoenix/blog/comment.ex") assert_file("test/phoenix_web/live/comment_live_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.CommentLiveTest" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_comments.exs") assert_file(path, fn file -> assert file =~ "create table(:comments)" assert file =~ "add :title, :string" end) assert_file("lib/phoenix_web/live/comment_live/index.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentLive.Index" end) assert_file("lib/phoenix_web/live/comment_live/show.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentLive.Show" end) assert_file("lib/phoenix_web/live/comment_live/form.ex", fn file -> assert file =~ "defmodule PhoenixWeb.CommentLive.Form" end) assert_receive {:mix_shell, :info, [ """ Add the live routes to your browser scope in lib/phoenix_web/router.ex: live "/comments", CommentLive.Index, :index live "/comments/new", CommentLive.Form, :new live "/comments/:id", CommentLive.Show, :show live "/comments/:id/edit", CommentLive.Form, :edit """ ]} assert_receive( {:mix_shell, :info, [ """ You must update :phoenix_live_view to v0.18 or later and :phoenix_live_dashboard to v0.7 or later to use the features in this generator. """ ]} ) end) end test "generates without explicit context", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Post posts title content:text slug:unique votes:integer cost:decimal tags:array:text popular:boolean drafted_at:datetime status:enum:unpublished:published:deleted published_at:utc_datetime published_at_usec:utc_datetime_usec deleted_at:naive_datetime deleted_at_usec:naive_datetime_usec alarm:time alarm_usec:time_usec secret:uuid:redact announcement_date:date alarm:time metadata:map weight:float user_id:references:users )) assert_file("lib/phoenix/posts/post.ex") assert_file("lib/phoenix/posts.ex") assert_file("test/phoenix/posts_test.exs") assert_file("lib/phoenix_web/live/post_live/index.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostLive.Index" refute file =~ "dom_id:" end) end) end test "generates into existing context without prompt with --merge-with-existing-context", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Blog Post posts title)) assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_post!" assert file =~ "def list_posts" assert file =~ "def create_post" assert file =~ "def update_post" assert file =~ "def delete_post" assert file =~ "def change_post" end) Gen.Live.run(~w(Blog Comment comments message:string --merge-with-existing-context)) refute_received {:mix_shell, :info, ["You are generating into an existing context" <> _notice]} assert_file("lib/phoenix/blog.ex", fn file -> assert file =~ "def get_comment!" assert file =~ "def list_comments" assert file =~ "def create_comment" assert file =~ "def update_comment" assert file =~ "def delete_comment" assert file =~ "def change_comment" end) end) end test "with --web namespace generates namespaced web modules and directories", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Blog Post posts title:string --web Blog)) assert_file("lib/phoenix/blog/post.ex") assert_file("lib/phoenix/blog.ex") assert_file("test/phoenix/blog_test.exs") assert_file("lib/phoenix_web/live/blog/post_live/index.ex", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostLive.Index" end) assert_file("lib/phoenix_web/live/blog/post_live/show.ex", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostLive.Show" end) assert_file("lib/phoenix_web/live/blog/post_live/form.ex", fn file -> assert file =~ "defmodule PhoenixWeb.Blog.PostLive.Form" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(path, fn file -> assert file =~ "create table(:posts)" assert file =~ "add :title, :string" end) assert_file("lib/phoenix_web/live/blog/post_live/index.ex", fn file -> assert file =~ ~S|~p"/blog/posts/#{post}/edit"| assert file =~ ~S|~p"/blog/posts/new"| assert file =~ ~S|~p"/blog/posts/#{post}"| end) assert_file("lib/phoenix_web/live/blog/post_live/show.ex", fn file -> assert file =~ ~S|~p"/blog/posts"| assert file =~ ~S|~p"/blog/posts/#{@post}/edit?return_to=show"| end) assert_file("test/phoenix_web/live/blog/post_live_test.exs", fn file -> assert file =~ ~S|~p"/blog/posts"| assert file =~ ~S|~p"/blog/posts/new"| assert file =~ ~S|~p"/blog/posts/#{post}/edit"| end) assert_receive {:mix_shell, :info, [ """ Add the live routes to your Blog :browser scope in lib/phoenix_web/router.ex: scope "/blog", PhoenixWeb.Blog do pipe_through :browser ... live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Form, :new live "/posts/:id", PostLive.Show, :show live "/posts/:id/edit", PostLive.Form, :edit end """ ]} end) end test "with --no-context skips context and schema file generation", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Blog Post posts title:string --no-context)) refute_file("lib/phoenix/blog.ex") refute_file("lib/phoenix/blog/post.ex") assert Path.wildcard("priv/repo/migrations/*.exs") == [] assert_file("lib/phoenix_web/live/post_live/index.ex") assert_file("lib/phoenix_web/live/post_live/show.ex") assert_file("lib/phoenix_web/live/post_live/form.ex") assert_file("test/phoenix_web/live/post_live_test.exs") end) end test "with --no-schema skips schema file generation", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Blog Post posts title:string --no-schema)) assert_file("lib/phoenix/blog.ex") refute_file("lib/phoenix/blog/post.ex") assert Path.wildcard("priv/repo/migrations/*.exs") == [] assert_file("lib/phoenix_web/live/post_live/index.ex") assert_file("lib/phoenix_web/live/post_live/show.ex") assert_file("lib/phoenix_web/live/post_live/form.ex") assert_file("test/phoenix_web/live/post_live_test.exs") end) end test "with --no-context does not emit warning when context exists", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Blog Post posts title:string)) assert_file("lib/phoenix/blog.ex") assert_file("lib/phoenix/blog/post.ex") Gen.Live.run(~w(Blog Comment comments title:string --no-context)) refute_received {:mix_shell, :info, ["You are generating into an existing context" <> _]} assert_file("lib/phoenix_web/live/comment_live/index.ex") assert_file("lib/phoenix_web/live/comment_live/show.ex") assert_file("lib/phoenix_web/live/comment_live/form.ex") assert_file("test/phoenix_web/live/comment_live_test.exs") end) end test "with same singular and plural", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Tracker Series series value:integer)) assert_file("lib/phoenix/tracker.ex") assert_file("lib/phoenix/tracker/series.ex") assert_file("lib/phoenix_web/live/series_live/index.ex", fn file -> assert file =~ "|> stream(:series_collection, list_series())" end) assert_file("lib/phoenix_web/live/series_live/show.ex") assert_file("lib/phoenix_web/live/series_live/form.ex") assert_file("lib/phoenix_web/live/series_live/index.ex", fn file -> assert file =~ "@streams.series_collection" end) assert_file("test/phoenix_web/live/series_live_test.exs") end) end test "when more than 50 attributes are given", config do in_tmp_live_project(config.test, fn -> long_attribute_list = Enum.map_join(0..55, " ", &"attribute#{&1}:string") Gen.Live.run(~w(Blog Post posts title #{long_attribute_list})) assert_file("test/phoenix/blog_test.exs", fn file -> refute file =~ "...}" end) assert_file("test/phoenix_web/live/post_live_test.exs", fn file -> refute file =~ "...}" end) end) end describe "inside umbrella" do test "without context_app generators config uses web dir", config do in_tmp_live_umbrella_project(config.test, fn -> File.cd!("phoenix_web") Application.put_env(:phoenix, :generators, context_app: nil) Gen.Live.run(~w(Accounts User users name:string)) assert_file("lib/phoenix/accounts.ex") assert_file("lib/phoenix/accounts/user.ex") assert_file("lib/phoenix_web/live/user_live/index.ex", fn file -> assert file =~ "defmodule PhoenixWeb.UserLive.Index" assert file =~ "use PhoenixWeb, :live_view" end) assert_file("lib/phoenix_web/live/user_live/show.ex", fn file -> assert file =~ "defmodule PhoenixWeb.UserLive.Show" assert file =~ "use PhoenixWeb, :live_view" end) assert_file("lib/phoenix_web/live/user_live/form.ex", fn file -> assert file =~ "defmodule PhoenixWeb.UserLive.Form" assert file =~ "use PhoenixWeb, :live_view" end) assert_file("test/phoenix_web/live/user_live_test.exs", fn file -> assert file =~ "defmodule PhoenixWeb.UserLiveTest" end) end) end test "raises with false context_app", config do in_tmp_live_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: false) assert_raise Mix.Error, ~r/no context_app configured/, fn -> Gen.Live.run(~w(Accounts User users name:string)) end end) end test "with context_app generators config does not use web dir", config do in_tmp_live_umbrella_project(config.test, fn -> File.mkdir!("another_app") Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) File.cd!("phoenix") Gen.Live.run(~w(Accounts User users name:string)) assert_file("another_app/lib/another_app/accounts.ex") assert_file("another_app/lib/another_app/accounts/user.ex") assert_file("lib/phoenix/live/user_live/index.ex", fn file -> assert file =~ "defmodule Phoenix.UserLive.Index" assert file =~ "use Phoenix, :live_view" end) assert_file("lib/phoenix/live/user_live/show.ex", fn file -> assert file =~ "defmodule Phoenix.UserLive.Show" assert file =~ "use Phoenix, :live_view" end) assert_file("lib/phoenix/live/user_live/form.ex", fn file -> assert file =~ "defmodule Phoenix.UserLive.Form" assert file =~ "use Phoenix, :live_view" end) assert_file("test/phoenix/live/user_live_test.exs", fn file -> assert file =~ "defmodule Phoenix.UserLiveTest" end) end) end end test "with custom primary key", config do in_tmp_live_project(config.test, fn -> Gen.Live.run(~w(Blog Post posts title:string --primary-key post_id)) assert_file("lib/phoenix_web/live/post_live/index.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostLive.Index" assert file =~ ~S[dom_id: &"posts-#{&1.post_id}"] assert file =~ ~s[JS.push("delete", value: %{post_id: post.post_id})] end) assert_file("lib/phoenix_web/live/post_live/show.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostLive.Show" assert file =~ ~s[def mount(%{"post_id" => post_id}, _session, socket)] assert file =~ "Blog.get_post!(post_id)" end) assert_file("lib/phoenix_web/live/post_live/form.ex", fn file -> assert file =~ "defmodule PhoenixWeb.PostLive.Form" assert file =~ ~s[defp apply_action(socket, :edit, %{"post_id" => post_id}) do] end) end) end test "raises on schema named form" do assert_raise Mix.Error, ~r/cannot use form as the schema name because it conflicts with the LiveView assigns/, fn -> Mix.Tasks.Phx.Gen.Live.run(~w(Blog Form forms title:string)) end end test "respect route_prefix in scopes", config do in_tmp_live_project(config.test, fn -> with_scope_env( :phoenix, [ organization: [ module: Phoenix.Organizations.Scope, assign_key: :current_organization, access_path: [:organization, :id], route_access_path: [:organization, :slug], route_prefix: "/orgs/:slug" ] ], fn -> Gen.Live.run(~w(Blog Post posts title:string --scope organization)) assert_file("lib/phoenix_web/live/post_live/index.ex", fn file -> assert file =~ ~s|navigate={~p"/orgs/\#{@current_organization.organization.slug}/posts| assert file =~ ~s|navigate={~p"/orgs/\#{@current_organization.organization.slug}/posts/new"| end) assert_file("lib/phoenix_web/live/post_live/show.ex", fn file -> assert file =~ ~s|navigate={~p"/orgs/\#{@current_organization.organization.slug}/posts"| assert file =~ ~s|navigate={~p"/orgs/\#{@current_organization.organization.slug}/posts/\#{@post}/edit| end) assert_file("lib/phoenix_web/live/post_live/form.ex", fn file -> assert file =~ ~s|defp return_path(scope, "index", _post), do: ~p"/orgs/\#{scope.organization.slug}/posts"| end) assert_file("test/phoenix_web/live/post_live_test.exs", fn file -> assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts"| assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts/new"| assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts/\#{post}"| assert file =~ ~s|~p"/orgs/\#{scope.organization.slug}/posts/\#{post}/edit"| end) end ) end) end end ================================================ FILE: test/mix/tasks/phx.gen.notifier_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule MyTestApp.Mailer do end defmodule Mix.Tasks.Phx.Gen.NotifierTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen setup do Mix.Task.clear() :ok end test "new notifier", config do in_tmp_project(config.test, fn -> Gen.Notifier.run(~w(Accounts User welcome_user reset_password --no-compile)) assert_file("lib/phoenix/accounts/user_notifier.ex", fn file -> assert file =~ ~S|defmodule Phoenix.Accounts.UserNotifier do| assert file =~ ~S|import Swoosh.Email| assert file =~ ~S|alias Phoenix.Mailer| assert file =~ ~S|def deliver_welcome_user(%{name: name, email: email}) do| assert file =~ ~S|from({"Phoenix Team", "team@example.com"})| assert file =~ ~S|def deliver_reset_password(%{name: name, email: email}) do| assert file =~ ~S|from({"Phoenix Team", "team@example.com"})| assert file =~ ~S|Mailer.deliver()| end) assert_file("test/phoenix/accounts/user_notifier_test.exs", fn file -> assert file =~ ~S|defmodule Phoenix.Accounts.UserNotifierTest do| end) send(self(), {:mix_shell_input, :yes?, true}) send(self(), {:mix_shell_input, :yes?, true}) send(self(), {:mix_shell_input, :yes?, true}) Gen.Notifier.run(~w(Accounts User account_confirmation --no-compile)) assert_received {:mix_shell, :info, ["The following files conflict with new files to be generated:" <> notice]} assert notice =~ "user_notifier.ex" assert notice =~ "user_notifier_test.exs" assert_received {:mix_shell, :yes?, [question]} assert question =~ "Proceed with interactive overwrite?" assert_file("lib/phoenix/accounts/user_notifier.ex", fn file -> assert file =~ ~S|defmodule Phoenix.Accounts.UserNotifier do| assert file =~ ~S|import Swoosh.Email| assert file =~ ~S|alias Phoenix.Mailer| assert file =~ ~S|def deliver_account_confirmation(%{name: name, email: email}) do| assert file =~ ~S|from({"Phoenix Team", "team@example.com"})| refute file =~ ~S|def deliver_welcome_user(%{name: name, email: email}) do| refute file =~ ~S|def deliver_reset_password(%{name: name, email: email}) do| end) end) end test "generates nested notifier", config do in_tmp_project(config.test, fn -> Gen.Notifier.run(~w(Admin.Accounts User welcome_user reset_password --no-compile)) assert_file("lib/phoenix/admin/accounts/user_notifier.ex", fn file -> assert file =~ ~S|defmodule Phoenix.Admin.Accounts.UserNotifier do| assert file =~ ~S|import Swoosh.Email| assert file =~ ~S|alias Phoenix.Mailer| assert file =~ ~S|def deliver_welcome_user(%{name: name, email: email}) do| assert file =~ ~S|from({"Phoenix Team", "team@example.com"})| assert file =~ ~S|def deliver_reset_password(%{name: name, email: email}) do| assert file =~ ~S|from({"Phoenix Team", "team@example.com"})| assert file =~ ~S|Mailer.deliver()| end) end) end test "in an umbrella with a context_app, generates the notifier", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) Gen.Notifier.run(~w(Accounts User welcome_user reset_password --no-compile)) assert_file("another_app/lib/another_app/accounts/user_notifier.ex", fn file -> assert file =~ ~S|defmodule AnotherApp.Accounts.UserNotifier do| assert file =~ ~S|import Swoosh.Email| assert file =~ ~S|alias AnotherApp.Mailer| assert file =~ ~S|Mailer.deliver()| end) end) end test "invalid mix arguments", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/Expected the context, "blog", to be a valid module name/, fn -> Gen.Notifier.run(~w(blog Post new_post --no-compile)) end assert_raise Mix.Error, ~r/Expected the notifier, "posts", to be a valid module name/, fn -> Gen.Notifier.run(~w(Post posts new_post --no-compile)) end assert_raise Mix.Error, ~r/Cannot generate context Phoenix because it has the same name as the application/, fn -> Gen.Notifier.run(~w(Phoenix Post new_blog_post --no-compile)) end assert_raise Mix.Error, ~r/Cannot generate notifier Phoenix because it has the same name as the application/, fn -> Gen.Notifier.run(~w(Blog Phoenix new_blog_post --no-compile)) end assert_raise Mix.Error, ~r/Cannot generate notifier "Post" because one of the messages is invalid: "NewPost"/, fn -> Gen.Notifier.run(~w(Blog Post NewPost --no-compile)) end end) end test "maybe_print_mailer_installation_instructions/1", config do in_tmp_project(config.test, fn -> context = Mix.Phoenix.Context.new(MyContext.UserNotifier, []) Gen.Notifier.maybe_print_mailer_installation_instructions(context) assert_received {:mix_shell, :info, ["Unable to find the \"Phoenix.Mailer\"" <> notice]} assert notice =~ ~s(A mailer module like the following is expected to be defined) assert notice =~ ~s(in your application in order to send emails.) assert notice =~ ~s(defmodule Phoenix.Mailer do) assert notice =~ ~s(use Swoosh.Mailer, otp_app: :phoenix) assert notice =~ ~s(def deps do) assert notice =~ ~s(https://hexdocs.pm/swoosh) context_with_mailer = %{context | base_module: MyTestApp} Gen.Notifier.maybe_print_mailer_installation_instructions(context_with_mailer) refute_received {:mix_shell, :info, _info} end) end end ================================================ FILE: test/mix/tasks/phx.gen.presence_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.Gen.PresenceTest do use ExUnit.Case import MixHelper setup do Mix.Task.clear() :ok end test "generates presence" do in_tmp_project("generates presence", fn -> Mix.Tasks.Phx.Gen.Presence.run(["MyPresence"]) assert_file("lib/phoenix_web/channels/my_presence.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.MyPresence do| assert file =~ ~S|use Phoenix.Presence| assert file =~ ~S|otp_app: :phoenix| assert file =~ ~S|pubsub_server: Phoenix.PubSub| end) end) end test "passing no args defaults to Presence" do in_tmp_project("generates presence", fn -> Mix.Tasks.Phx.Gen.Presence.run([]) assert_file("lib/phoenix_web/channels/presence.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.Presence do| assert file =~ ~S|use Phoenix.Presence| assert file =~ ~S|otp_app: :phoenix| assert file =~ ~S|pubsub_server: Phoenix.PubSub| end) end) end test "in an umbrella with a context_app, the file goes in lib/app/channels" do in_tmp_umbrella_project("generates presences", fn -> Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) Mix.Tasks.Phx.Gen.Presence.run([]) assert_file("lib/phoenix/channels/presence.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.Presence do| assert file =~ ~S|use Phoenix.Presence| assert file =~ ~S|otp_app: :phoenix| assert file =~ ~S|pubsub_server: AnotherApp.PubSub| end) end) end end ================================================ FILE: test/mix/tasks/phx.gen.release_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Mix.Tasks.Phx.Gen.ReleaseTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen @moduletag :capture_log setup do Mix.Task.clear() Process.put({Mix.Tasks.Phx.Gen.Release, :http_client}, fn url -> case to_string(url) do "https://hub.docker.com/v2/namespaces/hexpm/repositories/elixir/tags?" <> _ -> Phoenix.json_library().encode!(%{ results: [%{name: "1.18.4-erlang-25.3.2.17-debian-trixie-20251117-slim"}] }) end end) :ok end test "generates release files", config do in_tmp_project(config.test, fn -> Gen.Release.run(["--ecto"]) assert_file("lib/phoenix/release.ex", fn file -> assert file =~ ~S|defmodule Phoenix.Release do| assert file =~ ~S|@app :phoenix| end) assert_file("rel/overlays/bin/migrate", fn file -> assert file =~ ~S|exec ./phoenix eval Phoenix.Release.migrate| end) assert_file("rel/overlays/bin/migrate.bat", fn file -> assert file =~ ~S|call "%~dp0\phoenix" eval Phoenix.Release.migrate| end) assert_file("rel/overlays/bin/server", fn file -> assert file =~ ~S|PHX_SERVER=true exec ./phoenix start| end) assert_file("rel/overlays/bin/server.bat", fn file -> assert file =~ "set PHX_SERVER=true\ncall \"%~dp0\\phoenix\" start" end) refute_file("Dockerfile") refute_file(".dockerignore") refute_receive {:mix_shell, :info, ["* creating Dockerfile"]} refute_receive {:mix_shell, :info, ["* creating .dockerignore"]} assert_receive {:mix_shell, :info, ["* creating lib/phoenix/release.ex"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/migrate"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/migrate.bat"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/server"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/server.bat"]} assert_receive {:mix_shell, :info, ["\nYour application is ready to be deployed" <> _]} end) end test "generates release files without ecto", config do in_tmp_project(config.test, fn -> Gen.Release.run([]) assert_file("rel/overlays/bin/server", fn file -> assert file =~ ~S|PHX_SERVER=true exec ./phoenix start| end) refute_file("lib/phoenix/release.ex") refute_file("rel/overlays/bin/migrate") refute_file("rel/overlays/bin/migrate.bat") refute_file("Dockerfile") refute_file(".dockerignore") refute_receive {:mix_shell, :info, ["* creating Dockerfile"]} refute_receive {:mix_shell, :info, ["* creating .dockerignore"]} refute_receive {:mix_shell, :info, ["* creating lib/phoenix/release.ex"]} refute_receive {:mix_shell, :info, ["* creating rel/overlays/bin/migrate"]} refute_receive {:mix_shell, :info, ["* creating rel/overlays/bin/migrate.bat"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/server"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/server.bat"]} assert_receive {:mix_shell, :info, ["\nYour application is ready to be deployed" <> _]} end) end test "generates release and docker files", config do in_tmp_project(config.test, fn -> Gen.Release.run(["--docker", "--ecto"]) assert_file("lib/phoenix/release.ex", fn file -> assert file =~ ~S|defmodule Phoenix.Release do| assert file =~ ~S|@app :phoenix| end) assert_file("Dockerfile", fn file -> assert file =~ ~S|COPY --from=builder --chown=nobody:root /app/_build/${MIX_ENV}/rel/phoenix ./| assert file =~ ~S|CMD ["/app/bin/server"]| end) assert_file("rel/overlays/bin/migrate", fn file -> assert file =~ ~S|exec ./phoenix eval Phoenix.Release.migrate| end) assert_file("rel/overlays/bin/migrate.bat", fn file -> assert file =~ ~S|call "%~dp0\phoenix" eval Phoenix.Release.migrate| end) assert_file("rel/overlays/bin/server", fn file -> assert file =~ ~S|PHX_SERVER=true exec ./phoenix start| end) assert_file("rel/overlays/bin/server.bat", fn file -> assert file =~ "set PHX_SERVER=true\ncall \"%~dp0\\phoenix\" start" end) assert_file(".dockerignore") assert_receive {:mix_shell, :info, ["* creating Dockerfile"]} assert_receive {:mix_shell, :info, ["* creating .dockerignore"]} assert_receive {:mix_shell, :info, ["* creating lib/phoenix/release.ex"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/migrate"]} assert_receive {:mix_shell, :info, ["* creating rel/overlays/bin/server"]} assert_receive {:mix_shell, :info, ["\nYour application is ready to be deployed" <> _]} end) end test "generates release and docker files with assets dir", config do in_tmp_project(config.test, fn -> File.mkdir_p!("assets") Gen.Release.run(["--docker"]) assert_file("Dockerfile", fn file -> assert file =~ ~S|RUN mix assets.setup| assert file =~ ~S|COPY assets assets| assert file =~ ~S|RUN mix assets.deploy| end) end) end test "generates release and docker files without assets dir", config do in_tmp_project(config.test, fn -> Gen.Release.run(["--docker"]) assert_file("Dockerfile", fn file -> refute file =~ ~S|RUN mix assets.setup| refute file =~ ~S|COPY assets assets| refute file =~ ~S|RUN mix assets.deploy| end) end) end end ================================================ FILE: test/mix/tasks/phx.gen.schema_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule Phoenix.DupSchema do end defmodule Mix.Tasks.Phx.Gen.SchemaTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen alias Mix.Phoenix.Schema setup do Mix.Task.clear() :ok end test "build" do in_tmp_project("build", fn -> schema = Gen.Schema.build(~w(Blog.Post posts title:string tags:map), []) assert %Schema{ alias: Post, module: Phoenix.Blog.Post, repo: Phoenix.Repo, migration?: true, migration_defaults: %{title: ""}, plural: "posts", singular: "post", human_plural: "Posts", human_singular: "Post", attrs: [title: :string, tags: :map], types: [title: :string, tags: :map], optionals: [:tags], route_helper: "post", defaults: %{title: "", tags: ""}, scope: nil } = schema assert String.ends_with?(schema.file, "lib/phoenix/blog/post.ex") end) end test "build with default scope", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ] ], fn -> schema = Gen.Schema.build(~w(Blog.Post posts title:string), []) assert %Schema{ scope: %Mix.Phoenix.Scope{ name: :user, default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users } } = schema end ) end) end test "build with specific scope", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ user: [ default: false, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ], org: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :org_id], schema_key: :org_id, schema_type: :id, schema_table: :organizations ] ], fn -> schema = Gen.Schema.build(~w(Blog.Post posts title:string --scope org), []) assert %Schema{ scope: %Mix.Phoenix.Scope{ name: :org, default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :org_id], schema_key: :org_id, schema_type: :id, schema_table: :organizations } } = schema end ) end) end test "build with nested web namespace", config do in_tmp_project(config.test, fn -> schema = Gen.Schema.build(~w(Blog.Post posts title:string --web API.V1), []) assert %Schema{ alias: Post, module: Phoenix.Blog.Post, repo: Phoenix.Repo, migration?: true, migration_defaults: %{title: ""}, plural: "posts", singular: "post", human_plural: "Posts", human_singular: "Post", attrs: [title: :string], types: [title: :string], route_helper: "api_v1_post", defaults: %{title: ""}, scope: nil } = schema assert String.ends_with?(schema.file, "lib/phoenix/blog/post.ex") end) end test "table name missing from references", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/expect the table to be given to user_id:references/, fn -> Gen.Schema.run(~w(Blog.Post posts user_id:references)) end end) end test "type missing from array", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, ~r/expect the type of the array to be given to settings:array/, fn -> Gen.Schema.run(~w(Blog.Post posts settings:array)) end end) end test "plural can't contain a colon" do assert_raise Mix.Error, fn -> Gen.Schema.run(~w(Blog Post title:string)) end end test "plural can't have uppercased characters or camelized format" do assert_raise Mix.Error, fn -> Gen.Schema.run(~w(Blog Post Posts title:string)) end assert_raise Mix.Error, fn -> Gen.Schema.run(~w(Blog Post BlogPosts title:string)) end end test "table name omitted", config do in_tmp_project(config.test, fn -> assert_raise Mix.Error, fn -> Gen.Schema.run(~w(Blog.Post)) end end) end test "generates schema", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string)) assert_file("lib/phoenix/blog/post.ex") assert [migration] = Path.wildcard("priv/repo/migrations/*_create_blog_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:blog_posts) do" end) end) end test "allows a custom repo", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string --repo MyApp.CustomRepo)) assert [migration] = Path.wildcard("priv/custom_repo/migrations/*_create_blog_posts.exs") assert_file(migration, fn file -> assert file =~ "defmodule MyApp.CustomRepo.Migrations.CreateBlogPosts do" end) end) end test "allows a custom migration dir", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string --migration-dir priv/custom_dir)) assert [migration] = Path.wildcard("priv/custom_dir/*_create_blog_posts.exs") assert_file(migration, fn file -> assert file =~ "defmodule Phoenix.Repo.Migrations.CreateBlogPosts do" end) end) end test "custom migration_dir takes precedence over custom repo name", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string \ --repo MyApp.CustomRepo --migration-dir priv/custom_dir)) assert [migration] = Path.wildcard("priv/custom_dir/*_create_blog_posts.exs") assert_file(migration, fn file -> assert file =~ "defmodule MyApp.CustomRepo.Migrations.CreateBlogPosts do" end) end) end test "does not add maps to the required list", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string tags:map published_at:naive_datetime)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "cast(attrs, [:title, :tags, :published_at]" assert file =~ "validate_required([:title, :published_at]" end) end) end test "generates nested schema", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Admin.User users name:string)) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_users.exs") assert_file(migration, fn file -> assert file =~ "defmodule Phoenix.Repo.Migrations.CreateUsers do" assert file =~ "create table(:users) do" end) assert_file("lib/phoenix/blog/admin/user.ex", fn file -> assert file =~ "defmodule Phoenix.Blog.Admin.User do" assert file =~ "schema \"users\" do" end) end) end test "generates custom table name", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post posts --table cms_posts)) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_cms_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:cms_posts) do" end) end) end test "generates unique indices", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post posts title:unique secret:redact unique_int:integer:unique)) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "defmodule Phoenix.Repo.Migrations.CreatePosts do" assert file =~ "create table(:posts) do" assert file =~ "add :title, :string" assert file =~ "add :unique_int, :integer" assert file =~ "add :secret, :string" assert file =~ "create unique_index(:posts, [:title])" assert file =~ "create unique_index(:posts, [:unique_int])" end) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "defmodule Phoenix.Blog.Post do" assert file =~ "schema \"posts\" do" assert file =~ "field :title, :string" assert file =~ "field :unique_int, :integer" assert file =~ "field :secret, :string, redact: true" end) end) end test "generates references and belongs_to associations", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post posts title user_id:references:users)) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "add :user_id, references(:users, on_delete: :nothing)" assert file =~ "create index(:posts, [:user_id])" end) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "field :user_id, :id" end) end) end test "generates references with unique indexes", config do in_tmp_project(config.test, fn -> Gen.Schema.run( ~w(Blog.Post posts title user_id:references:users unique_post_id:references:posts:unique) ) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "defmodule Phoenix.Repo.Migrations.CreatePosts do" assert file =~ "create table(:posts) do" assert file =~ "add :user_id, references(:users, on_delete: :nothing)" assert file =~ "add :unique_post_id, references(:posts, on_delete: :nothing)" assert file =~ "create index(:posts, [:user_id])" assert file =~ "create unique_index(:posts, [:unique_post_id])" end) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "defmodule Phoenix.Blog.Post do" assert file =~ "field :user_id, :id" assert file =~ "field :unique_post_id, :id" end) end) end test "generates schema with proper datetime types", config do in_tmp_project(config.test, fn -> Gen.Schema.run( ~w(Blog.Comment comments title:string drafted_at:datetime published_at:naive_datetime edited_at:utc_datetime locked_at:naive_datetime_usec) ) assert_file("lib/phoenix/blog/comment.ex", fn file -> assert file =~ "field :drafted_at, :naive_datetime" assert file =~ "field :published_at, :naive_datetime" assert file =~ "field :locked_at, :naive_datetime_usec" assert file =~ "field :edited_at, :utc_datetime" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_comments.exs") assert_file(path, fn file -> assert file =~ "create table(:comments)" assert file =~ "add :drafted_at, :naive_datetime" assert file =~ "add :published_at, :naive_datetime" assert file =~ "add :edited_at, :utc_datetime" end) end) end test "generates schema with enum", config do in_tmp_project(config.test, fn -> Gen.Schema.run( ~w(Blog.Comment comments title:string status:enum:unpublished:published:deleted) ) assert_file("lib/phoenix/blog/comment.ex", fn file -> assert file =~ "field :status, Ecto.Enum, values: [:unpublished, :published, :deleted]" end) assert [path] = Path.wildcard("priv/repo/migrations/*_create_comments.exs") assert_file(path, fn file -> assert file =~ "create table(:comments)" assert file =~ "add :status, :string" end) end) end test "generates migration with binary_id", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post posts title user_id:references:users --binary-id)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "field :user_id, :binary_id" end) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:posts, primary_key: false) do" assert file =~ "add :id, :binary_id, primary_key: true" assert file =~ "add :user_id, references(:users, on_delete: :nothing, type: :binary_id)" end) end) end test "generates migration with custom primary key", config do in_tmp_project(config.test, fn -> Gen.Schema.run( ~w(Blog.Post posts title user_id:references:users --binary-id --primary-key post_id) ) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "@derive {Phoenix.Param, key: :post_id}" assert file =~ "@primary_key {:post_id, :binary_id, autogenerate: true}" assert file =~ "field :user_id, :binary_id" end) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:posts, primary_key: false) do" assert file =~ "add :post_id, :binary_id, primary_key: true" assert file =~ "add :user_id, references(:users, on_delete: :nothing, type: :binary_id)" end) end) end test "generates schema and migration with prefix", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post posts title --prefix cms)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "@schema_prefix :cms" end) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:posts, prefix: :cms) do" end) end) end test "skips migration with --no-migration option", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post posts --no-migration)) assert [] = Path.wildcard("priv/repo/migrations/*") end) end test "uses defaults from :generators configuration" do in_tmp_project("uses defaults from generators configuration (migration)", fn -> with_generator_env([migration: false], fn -> Gen.Schema.run(~w(Blog.Post posts)) assert [] = Path.wildcard("priv/repo/migrations/*") end) end) in_tmp_project("uses defaults from generators configuration (binary_id)", fn -> with_generator_env([binary_id: true], fn -> Gen.Schema.run(~w(Blog.Post posts)) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:posts, primary_key: false) do" assert file =~ "add :id, :binary_id, primary_key: true" end) end) end) in_tmp_project("uses defaults from generators configuration (:utc_datetime)", fn -> with_generator_env([timestamp_type: :utc_datetime], fn -> Gen.Schema.run(~w(Blog.Post posts)) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "timestamps(type: :utc_datetime)" end) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "timestamps(type: :utc_datetime)" end) end) end) end test "generates migrations with a custom migration module", config do in_tmp_project(config.test, fn -> try do Application.put_env(:ecto_sql, :migration_module, MyCustomApp.MigrationModule) Gen.Schema.run(~w(Blog.Post posts)) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_posts.exs") assert_file(migration, fn file -> assert file =~ "use MyCustomApp.MigrationModule" assert file =~ "create table(:posts) do" end) after Application.delete_env(:ecto_sql, :migration_module) end end) end test "generates schema without extra line break", config do in_tmp_project(config.test, fn -> Gen.Schema.run(~w(Blog.Post posts title)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "import Ecto.Changeset\n\n schema" end) end) end describe "inside umbrella" do test "raises with false context_app", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: false) assert_raise Mix.Error, ~r/no context_app configured/, fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string)) end end) end test "with context_app set to nil", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: nil) Gen.Schema.run(~w(Blog.Post blog_posts title:string)) assert_file("lib/phoenix/blog/post.ex") assert [_] = Path.wildcard("priv/repo/migrations/*_create_blog_posts.exs") end) end test "with context_app", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) Gen.Schema.run(~w(Blog.Post blog_posts title:string)) assert_file("another_app/lib/another_app/blog/post.ex") assert [_] = Path.wildcard("another_app/priv/repo/migrations/*_create_blog_posts.exs") end) end test "generates scoped schema", config do in_tmp_umbrella_project(config.test, fn -> Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) with_scope_env( :another_app, [ org: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :org_id], schema_key: :org_id, schema_type: :id, schema_table: :organizations ] ], fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string --scope org --binary-id)) assert_file("another_app/lib/another_app/blog/post.ex", fn file -> assert file =~ "@primary_key {:id, :binary_id, autogenerate: true}" assert file =~ "field :org_id, :id" end) assert [migration] = Path.wildcard("another_app/priv/repo/migrations/*_create_blog_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:blog_posts, primary_key: false) do" assert file =~ "add :id, :binary_id, primary_key: true" assert file =~ "add :org_id, references(:organizations, type: :id, on_delete: :delete_all)" assert file =~ "create index(:blog_posts, [:org_id])" end) end ) end) end end test "generates scoped schema", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ org: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :org_id], schema_key: :org_id, schema_type: :id, schema_table: :organizations ] ], fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string --scope org --binary-id)) assert_file("lib/phoenix/blog/post.ex", fn file -> assert file =~ "@primary_key {:id, :binary_id, autogenerate: true}" assert file =~ "field :org_id, :id" end) assert [migration] = Path.wildcard("priv/repo/migrations/*_create_blog_posts.exs") assert_file(migration, fn file -> assert file =~ "create table(:blog_posts, primary_key: false) do" assert file =~ "add :id, :binary_id, primary_key: true" assert file =~ "add :org_id, references(:organizations, type: :id, on_delete: :delete_all)" assert file =~ "create index(:blog_posts, [:org_id])" end) end ) end) end test "raises when there are multiple default scopes" do with_scope_env( :phoenix, [ org: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :org_id], schema_key: :org_id, schema_type: :id, schema_table: :organizations ], user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ] ], fn -> assert_raise Mix.Error, ~r"There can only be one default scope", fn -> Gen.Schema.run(~w(Blog.Post blog_posts title:string)) end end ) end test "raises when a reference conflicts with the scope", config do in_tmp_project(config.test, fn -> with_scope_env( :phoenix, [ user: [ default: true, module: MyApp.Accounts.Scope, assign_key: :current_scope, access_path: [:user, :id], schema_key: :user_id, schema_type: :id, schema_table: :users ] ], fn -> assert_raise Mix.Error, ~r"Reference :user_id has the same name as the scope schema key, either skip the reference or pass it with the --no-scope flag.", fn -> Gen.Schema.run( ~w(Blog.Post blog_posts title:string user_id:references:users) ) end end ) end) end end ================================================ FILE: test/mix/tasks/phx.gen.secret_test.exs ================================================ Code.require_file "../../../installer/test/mix_helper.exs", __DIR__ defmodule Mix.Tasks.Phx.Gen.SecretTest do use ExUnit.Case import Mix.Tasks.Phx.Gen.Secret test "generates a secret" do run [] assert_receive {:mix_shell, :info, [secret]} when byte_size(secret) == 64 assert String.printable?(secret) end test "generates a secret with custom length" do run ["32"] assert_receive {:mix_shell, :info, [secret]} when byte_size(secret) == 32 assert String.printable?(secret) end test "raises on invalid args" do message = "mix phx.gen.secret expects a length as integer or no argument at all" assert_raise Mix.Error, message, fn -> run ["bad"] end assert_raise Mix.Error, message, fn -> run ["32bad"] end assert_raise Mix.Error, message, fn -> run ["32", "bad"] end end test "raises when length is too short" do message = "The secret should be at least 32 characters long" assert_raise Mix.Error, message, fn -> run ["0"] end assert_raise Mix.Error, message, fn -> run ["31"] end end end ================================================ FILE: test/mix/tasks/phx.gen.socket_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule PhoenixWeb.DupSocket do end defmodule Mix.Tasks.Phx.Gen.SocketTest do use ExUnit.Case import MixHelper alias Mix.Tasks.Phx.Gen setup do Mix.Task.clear() :ok end test "generates socket" do in_tmp_project("generates socket", fn -> Gen.Socket.run(["User"]) assert_file("lib/phoenix_web/channels/user_socket.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.UserSocket do| assert file =~ ~S|# Uncomment the following line to define a "room:*" topic| assert file =~ ~S|# pointing to the `PhoenixWeb.RoomChannel`:| assert file =~ ~S|# channel "room:*", PhoenixWeb.RoomChannel| assert file =~ ~S|def connect(_params, socket, _connect_info) do| assert file =~ ~S|def id(_socket), do: nil| end) assert_file("assets/js/user_socket.js", fn file -> assert file =~ ~S|// NOTE: The contents of this file will only be executed if| assert file =~ ~S|// you uncomment its entry in "assets/js/app.js".| assert file =~ ~S|// And connect to the path in "lib/phoenix_web/endpoint.ex".| assert file =~ ~S|let socket = new Socket("/socket", {authToken: window.userToken})| assert file =~ ~S|let channel = socket.channel("room:42", {})| assert file =~ ~S|channel.join()| end) end) assert_received {:mix_shell, :info, ["\nAdd the socket handler to your `lib/phoenix_web/endpoint.ex`" <> _]} end test "generates socket with channel declaration" do in_tmp_project("generates socket with channel declaration", fn -> Gen.Socket.run(~w(User --from-channel Chat)) assert_file("lib/phoenix_web/channels/user_socket.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.UserSocket do| refute file =~ ~S|# Uncomment the following line to define a "room:*" topic| assert file =~ ~S|channel "chat:*", PhoenixWeb.ChatChannel| end) end) end test "in an umbrella with a context_app, generates the files" do in_tmp_umbrella_project("generates channels", fn -> Application.put_env(:phoenix, :generators, context_app: {:another_app, "another_app"}) Gen.Socket.run(["Room"]) assert_file("lib/phoenix/channels/room_socket.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.RoomSocket do| end) assert_file("assets/js/room_socket.js", fn file -> assert file =~ ~S|// NOTE: The contents of this file will only be executed if| assert file =~ ~S|// you uncomment its entry in "assets/js/app.js".| assert file =~ ~S|// Bring in Phoenix channels client library:| assert file =~ ~S|import {Socket} from "phoenix"| assert file =~ ~S|// And connect to the path in "lib/phoenix/endpoint.ex".| assert file =~ ~S|Read the [`Using Token Authentication`](https://hexdocs.pm/phoenix/channels.html#using-token-authentication)| assert file =~ ~S|let channel = socket.channel("room:42", {})| assert file =~ ~S|channel.join()| end) end) assert_received {:mix_shell, :info, ["\nAdd the socket handler to your `lib/phoenix/endpoint.ex`" <> _]} end test "generates nested socket" do in_tmp_project("generates nested socket", fn -> Gen.Socket.run(["Admin.User"]) assert_file("lib/phoenix_web/channels/admin/user_socket.ex", fn file -> assert file =~ ~S|defmodule PhoenixWeb.Admin.UserSocket do| end) assert_file("assets/js/admin/user_socket.js", fn file -> assert file =~ ~S|// NOTE: The contents of this file will only be executed if| assert file =~ ~S|// you uncomment its entry in "assets/js/app.js".| assert file =~ ~S|// Bring in Phoenix channels client library:| assert file =~ ~S|import {Socket} from "phoenix"| assert file =~ ~S|// And connect to the path in "lib/phoenix_web/endpoint.ex".| assert file =~ ~S|let socket = new Socket("/socket", {authToken: window.userToken})| assert file =~ ~S|Read the [`Using Token Authentication`](https://hexdocs.pm/phoenix/channels.html#using-token-authentication)| assert file =~ ~S|let channel = socket.channel("room:42", {})| assert file =~ ~S|channel.join()| end) end) assert_received {:mix_shell, :info, ["\nAdd the socket handler to your `lib/phoenix_web/endpoint.ex`" <> _]} end test "passing no args raises error" do assert_raise Mix.Error, fn -> Gen.Socket.run([]) end end test "passing invalid name raises error" do assert_raise Mix.Error, fn -> Gen.Socket.run(["room"]) end end test "passing extra args raises error" do assert_raise Mix.Error, fn -> Gen.Socket.run(["Admin.User", "new_message"]) end end test "name is already defined" do assert_raise Mix.Error, ~r/DupSocket is already taken/, fn -> Gen.Socket.run(["Dup"]) end end end ================================================ FILE: test/mix/tasks/phx.routes_test.exs ================================================ Code.require_file("../../../installer/test/mix_helper.exs", __DIR__) defmodule PageController do def init(opts), do: opts def call(conn, _opts), do: conn defmodule Live do def init(opts), do: opts end end defmodule PhoenixTestWeb.Router do use Phoenix.Router get "/", PageController, :index, as: :page end defmodule PhoenixTestOld.Router do use Phoenix.Router get "/old", PageController, :index, as: :page end defmodule PhoenixTestLiveWeb.Router do use Phoenix.Router get "/", PageController, :index, metadata: %{mfa: {PageController.Live, :init, 1}} end defmodule PhoenixTestWeb.ForwardedRouter do use Phoenix.Router forward "/", PhoenixTestWeb.PlugRouterWithVerifiedRoutes end defmodule PhoenixTestWeb.PlugRouterWithVerifiedRoutes do use Plug.Router @behaviour Phoenix.VerifiedRoutes get "/foo" do send_resp(conn, 200, "ok") end @impl Phoenix.VerifiedRoutes def formatted_routes(_plug_opts) do [ %{verb: "GET", path: "/foo", label: "Hello"} ] end @impl Phoenix.VerifiedRoutes def verified_route?(_plug_opts, path) do path == ["foo"] end end defmodule Mix.Tasks.Phx.RoutesTest do use ExUnit.Case, async: true test "format routes for specific router" do Mix.Tasks.Phx.Routes.run(["PhoenixTestWeb.Router", "--no-compile"]) assert_received {:mix_shell, :info, [routes]} assert routes =~ "page_path GET / PageController :index" end test "format routes for forwarded router that implements verified routes" do Mix.Tasks.Phx.Routes.run(["PhoenixTestWeb.ForwardedRouter", "--no-compile"]) assert_received {:mix_shell, :info, [routes]} assert routes =~ "GET /foo Hello" end test "prints error when explicit router cannot be found" do assert_raise Mix.Error, "the provided router, Foo.UnknownBar.CantFindBaz, does not exist", fn -> Mix.Tasks.Phx.Routes.run(["Foo.UnknownBar.CantFindBaz", "--no-compile"]) end end test "prints error when implicit router cannot be found" do assert_raise Mix.Error, ~r/no router found at FooWeb.Router or Foo.Router/, fn -> Mix.Tasks.Phx.Routes.run(["--no-compile"], Foo) end end test "implicit router detection for web namespace" do Mix.Tasks.Phx.Routes.run(["--no-compile"], PhoenixTest) assert_received {:mix_shell, :info, [routes]} assert routes =~ "page_path GET / PageController :index" end test "implicit router detection fallback for old namespace" do Mix.Tasks.Phx.Routes.run(["--no-compile"], PhoenixTestOld) assert_received {:mix_shell, :info, [routes]} assert routes =~ "page_path GET /old PageController :index" end test "overrides module name for route with :mfa metadata" do Mix.Tasks.Phx.Routes.run(["PhoenixTestLiveWeb.Router", "--no-compile"]) assert_received {:mix_shell, :info, [routes]} assert routes =~ "page_path GET / PageController.Live :index" end end ================================================ FILE: test/mix/tasks/phx_test.exs ================================================ defmodule Mix.Tasks.Phx.Test do use ExUnit.Case test "provide a list of available phx mix tasks" do Mix.Tasks.Phx.run [] assert_received {:mix_shell, :info, ["mix phx.digest" <> _]} assert_received {:mix_shell, :info, ["mix phx.digest.clean" <> _]} assert_received {:mix_shell, :info, ["mix phx.gen.channel" <> _]} assert_received {:mix_shell, :info, ["mix phx.gen.cert" <> _]} assert_received {:mix_shell, :info, ["mix phx.gen.context" <> _]} assert_received {:mix_shell, :info, ["mix phx.gen.embedded" <> _]} assert_received {:mix_shell, :info, ["mix phx.gen.html" <> _]} assert_received {:mix_shell, :info, ["mix phx.gen.json" <> _]} assert_received {:mix_shell, :info, ["mix phx.gen.live" <> _]} end test "expects no arguments" do assert_raise Mix.Error, fn -> Mix.Tasks.Phx.run ["invalid"] end end end ================================================ FILE: test/phoenix/channel_test.exs ================================================ defmodule Phoenix.Channel.ChannelTest do use ExUnit.Case, async: true @pubsub __MODULE__.PubSub import Phoenix.Channel setup_all do start_supervised! {Phoenix.PubSub, name: @pubsub, pool_size: 1} :ok end test "broadcasts from self" do Phoenix.PubSub.subscribe(@pubsub, "sometopic") socket = %Phoenix.Socket{ pubsub_server: @pubsub, topic: "sometopic", channel_pid: self(), joined: true } broadcast_from(socket, "event1", %{key: :val}) refute_received %Phoenix.Socket.Broadcast{ event: "event1", payload: %{key: :val}, topic: "sometopic" } broadcast_from!(socket, "event2", %{key: :val}) refute_received %Phoenix.Socket.Broadcast{ event: "event2", payload: %{key: :val}, topic: "sometopic" } broadcast(socket, "event3", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event3", payload: %{key: :val}, topic: "sometopic" } broadcast!(socket, "event4", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event4", payload: %{key: :val}, topic: "sometopic" } end test "broadcasts from other" do Phoenix.PubSub.subscribe(@pubsub, "sometopic") socket = %Phoenix.Socket{ pubsub_server: @pubsub, topic: "sometopic", channel_pid: spawn_link(fn -> :ok end), joined: true } broadcast_from(socket, "event1", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event1", payload: %{key: :val}, topic: "sometopic" } broadcast_from!(socket, "event2", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event2", payload: %{key: :val}, topic: "sometopic" } broadcast(socket, "event3", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event3", payload: %{key: :val}, topic: "sometopic" } broadcast!(socket, "event4", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event4", payload: %{key: :val}, topic: "sometopic" } end test "pushing to transport" do socket = %Phoenix.Socket{ serializer: Phoenix.ChannelTest.NoopSerializer, topic: "sometopic", transport_pid: self(), joined: true } push(socket, "event1", %{key: :val}) assert_receive %Phoenix.Socket.Message{ event: "event1", payload: %{key: :val}, topic: "sometopic" } end test "replying to transport" do socket = %Phoenix.Socket{ serializer: Phoenix.ChannelTest.NoopSerializer, ref: "123", topic: "sometopic", transport_pid: self(), joined: true } ref = socket_ref(socket) reply(ref, {:ok, %{key: :val}}) assert_receive %Phoenix.Socket.Reply{ payload: %{key: :val}, ref: "123", status: :ok, topic: "sometopic" } end test "replying just status to transport" do socket = %Phoenix.Socket{ serializer: Phoenix.ChannelTest.NoopSerializer, ref: "123", topic: "sometopic", transport_pid: self(), joined: true } ref = socket_ref(socket) reply(ref, :ok) assert_receive %Phoenix.Socket.Reply{ payload: %{}, ref: "123", status: :ok, topic: "sometopic" } end test "socket_ref raises ArgumentError when socket is not joined or has no ref" do assert_raise ArgumentError, ~r"join", fn -> socket_ref(%Phoenix.Socket{joined: false}) end assert_raise ArgumentError, ~r"ref", fn -> socket_ref(%Phoenix.Socket{joined: true}) end end end ================================================ FILE: test/phoenix/code_reloader_test.exs ================================================ defmodule Phoenix.CodeReloaderTest do use ExUnit.Case, async: true use RouterHelper defmodule Endpoint do def config(:reloadable_compilers), do: [:unknown_compiler, :elixir] def config(:reloadable_apps), do: nil end def reload(_, _) do {:error, "oops \e[31merror"} end @tag :capture_log test "syncs with code server" do assert Phoenix.CodeReloader.sync() == :ok # Suspend so we can monitor the process until we get a reply. # There is an inherent race condition here in that the process # may die before we request but the code should work in both # cases, so we are fine. :sys.suspend(Phoenix.CodeReloader.Server) ref = Process.monitor(Phoenix.CodeReloader.Server) Task.start_link(fn -> Phoenix.CodeReloader.Server |> Process.whereis() |> Process.exit(:kill) end) assert Phoenix.CodeReloader.sync() == :ok assert_receive {:DOWN, ^ref, _, _, _} wait_until_is_up(Phoenix.CodeReloader.Server) end test "reloads on every request" do pid = Process.whereis(Phoenix.CodeReloader.Server) :erlang.trace(pid, true, [:receive]) opts = Phoenix.CodeReloader.init([]) conn = conn(:get, "/") |> Plug.Conn.put_private(:phoenix_endpoint, Endpoint) |> Phoenix.CodeReloader.call(opts) assert conn.state == :unset assert_receive {:trace, ^pid, :receive, {_, _, {:reload!, Endpoint, _}}} end test "renders compilation error on failure" do opts = Phoenix.CodeReloader.init(reloader: &__MODULE__.reload/2) conn = conn(:get, "/") |> Plug.Conn.put_private(:phoenix_endpoint, Endpoint) |> Phoenix.CodeReloader.call(opts) assert conn.state == :sent assert conn.status == 500 assert conn.resp_body =~ "oops error" assert conn.resp_body =~ "CompileError" assert conn.resp_body =~ "Compilation error" end defp wait_until_is_up(process) do if Process.whereis(process) do :ok else Process.sleep(10) wait_until_is_up(process) end end end ================================================ FILE: test/phoenix/config_test.exs ================================================ defmodule Phoenix.ConfigTest do use ExUnit.Case, async: true import Phoenix.Config @defaults [static: [at: "/"]] @config [parsers: false, custom: true, otp_app: :phoenix_config] @all @config ++ @defaults test "reads configuration from env", meta do Application.put_env(:config_app, meta.test, @config) config = from_env(:config_app, meta.test, [static: true]) assert config[:parsers] == false assert config[:custom] == true assert config[:static] == true end test "starts an ets table as part of the module", meta do {:ok, _pid} = start_link({meta.test, @all, @defaults, []}) assert :ets.info(meta.test, :name) == meta.test assert :ets.lookup(meta.test, :parsers) == [parsers: false] assert :ets.lookup(meta.test, :static) == [static: [at: "/"]] assert :ets.lookup(meta.test, :custom) == [custom: true] end test "raises with warning about compile time when table not started" do assert_raise RuntimeError, "could not find ets table for endpoint Fooz. Make sure your endpoint is started and note you cannot access endpoint functions at compile-time", fn -> cache(Fooz, :foo, fn _ -> {:nocache, :bar} end) end end test "can change configuration", meta do {:ok, pid} = start_link({meta.test, @all, @defaults, []}) ref = Process.monitor(pid) # Nothing changed config_change(meta.test, [], []) assert :ets.lookup(meta.test, :parsers) == [parsers: false] assert :ets.lookup(meta.test, :static) == [static: [at: "/"]] assert :ets.lookup(meta.test, :custom) == [custom: true] # Something changed config_change(meta.test, [{meta.test, parsers: true}], []) assert :ets.lookup(meta.test, :parsers) == [parsers: true] assert :ets.lookup(meta.test, :static) == [static: [at: "/"]] assert :ets.lookup(meta.test, :custom) == [] # Module removed config_change(meta.test, [], [meta.test]) assert_receive {:DOWN, ^ref, :process, ^pid, :normal} assert :ets.info(meta.test, :name) == :undefined end test "can cache", meta do {:ok, _pid} = start_link({meta.test, @all, @defaults, []}) assert cache(meta.test, :__hello__, fn _ -> {:nocache, 1} end) == 1 assert cache(meta.test, :__hello__, fn _ -> {:cache, 2} end) == 2 assert cache(meta.test, :__hello__, fn _ -> {:cache, 3} end) == 2 assert cache(meta.test, :__hello__, fn _ -> {:nocache, 3} end) == 2 # Cache is reloaded on config_change config_change(meta.test, [{meta.test, []}], []) assert cache(meta.test, :__hello__, fn _ -> {:nocache, 4} end) == 4 assert cache(meta.test, :__hello__, fn _ -> {:cache, 5} end) == 5 assert cache(meta.test, :__hello__, fn _ -> {:cache, 6} end) == 5 # Cache is cleaned on clear_cache clear_cache(meta.test) assert cache(meta.test, :__hello__, fn _ -> {:nocache, 7} end) == 7 assert cache(meta.test, :__hello__, fn _ -> {:cache, 8} end) == 8 assert cache(meta.test, :__hello__, fn _ -> {:cache, 9} end) == 8 end end ================================================ FILE: test/phoenix/controller/controller_test.exs ================================================ defmodule Phoenix.Controller.ControllerTest do use ExUnit.Case, async: true use RouterHelper import ExUnit.CaptureIO import Phoenix.Controller alias Plug.Conn setup do Logger.put_process_level(self(), :none) :ok end defp get_resp_content_type(conn) do [header] = get_resp_header(conn, "content-type") header |> String.split(";") |> Enum.fetch!(0) end test "action_name/1" do conn = put_private(%Conn{}, :phoenix_action, :show) assert action_name(conn) == :show end test "controller_module/1" do conn = put_private(%Conn{}, :phoenix_controller, Hello) assert controller_module(conn) == Hello end test "router_module/1" do conn = put_private(%Conn{}, :phoenix_router, Hello) assert router_module(conn) == Hello end test "endpoint_module/1" do conn = put_private(%Conn{}, :phoenix_endpoint, Hello) assert endpoint_module(conn) == Hello end test "view_template/1" do conn = put_private(%Conn{}, :phoenix_template, "hello.html") assert view_template(conn) == "hello.html" assert view_template(%Conn{}) == nil end test "status_message_from_template/1" do assert status_message_from_template("404.html") == "Not Found" assert status_message_from_template("whatever.html") == "Internal Server Error" end test "put_layout/2 and layout/1" do conn = conn(:get, "/") assert layout(conn) == false conn = put_layout(conn, {AppView, "app.html"}) assert layout(conn) == {AppView, "app.html"} assert capture_io(:stderr, fn -> conn = put_layout(conn, "print.html") assert layout(conn) == {AppView, "print.html"} end) =~ "specifying put_layout(conn, template) or put_new_layout(conn, template) is deprecated" assert capture_io(:stderr, fn -> conn = put_layout(conn, :print) assert layout(conn) == {AppView, :print} end) =~ "specifying put_layout(conn, template) or put_new_layout(conn, template) is deprecated" conn = put_layout(conn, false) assert layout(conn) == false assert_raise RuntimeError, fn -> put_layout(conn, "print") end assert_raise Plug.Conn.AlreadySentError, fn -> put_layout(sent_conn(), {AppView, :print}) end end test "put_layout/2 and layout/1 with formats" do conn = conn(:get, "/") |> put_format("html") assert layout(conn) == false conn = put_layout(conn, html: {AppView, :app}) assert layout(conn) == {AppView, :app} assert capture_io(:stderr, fn -> conn = put_layout(conn, html: :print) assert layout(conn) == {AppView, :print} end) =~ "specifying a layout without module is deprecated, use html: {AppView, :print} instead" conn = put_layout(conn, html: {AppView, :app}, print: {AppView, :print}) conn = put_format(conn, "html") assert layout(conn) == {AppView, :app} conn = put_format(conn, "print") assert layout(conn) == {AppView, :print} message = """ the response was already sent. Status code: 200 Request path: / Method: GET Layout: {AppView, :print} """ assert_raise Plug.Conn.AlreadySentError, message, fn -> put_layout(sent_conn(), {AppView, :print}) end end test "put_root_layout/2 and root_layout/1" do conn = conn(:get, "/") assert root_layout(conn) == false conn = put_root_layout(conn, {AppView, "root.html"}) assert root_layout(conn) == {AppView, "root.html"} assert capture_io(:stderr, fn -> conn = put_root_layout(conn, "bare.html") assert root_layout(conn) == {AppView, "bare.html"} end) =~ "specifying put_layout(conn, template) or put_new_layout(conn, template) is deprecated" assert capture_io(:stderr, fn -> conn = put_root_layout(conn, :print) assert root_layout(conn) == {AppView, :print} end) =~ "specifying put_layout(conn, template) or put_new_layout(conn, template) is deprecated" conn = put_root_layout(conn, false) assert root_layout(conn) == false assert_raise RuntimeError, fn -> put_root_layout(conn, "print") end assert_raise Plug.Conn.AlreadySentError, fn -> put_layout(sent_conn(), {AppView, :print}) end end test "put_root_layout/2 and root_layout/1 with formats" do conn = conn(:get, "/") |> put_format("html") assert root_layout(conn) == false conn = put_root_layout(conn, html: {AppView, :app}) assert root_layout(conn) == {AppView, :app} assert capture_io(:stderr, fn -> conn = put_root_layout(conn, html: :print) assert root_layout(conn) == {AppView, :print} end) =~ "specifying a layout without module is deprecated, use html: {AppView, :print} instead" conn = put_root_layout(conn, html: {AppView, :app}, print: {AppView, :print}) conn = put_format(conn, "html") assert root_layout(conn) == {AppView, :app} conn = put_format(conn, "print") assert root_layout(conn) == {AppView, :print} assert_raise Plug.Conn.AlreadySentError, fn -> put_root_layout(sent_conn(), {AppView, :print}) end end test "put_new_layout/2" do conn = put_new_layout(conn(:get, "/"), false) assert layout(conn) == false conn = put_new_layout(conn, {AppView, "app.html"}) assert layout(conn) == false conn = put_new_layout(conn(:get, "/"), {AppView, "app.html"}) assert layout(conn) == {AppView, "app.html"} conn = put_new_layout(conn, false) assert layout(conn) == {AppView, "app.html"} assert_raise Plug.Conn.AlreadySentError, fn -> put_new_layout(sent_conn(), {AppView, "app.html"}) end end test "put_new_layout/2 with formats" do conn = put_new_layout(conn(:get, "/"), html: false, json: false) conn = put_format(conn, "html") assert layout(conn) == false conn = put_new_layout(conn, html: {AppView, :app}) assert layout(conn) == false conn = put_new_layout(conn(:get, "/"), html: {AppView, :app}, json: false) conn = put_format(conn, "html") assert layout(conn) == {AppView, :app} conn = put_new_layout(conn, false) assert layout(conn) == false conn = put_format(conn, "json") assert layout(conn) == false assert_raise Plug.Conn.AlreadySentError, fn -> put_new_layout(sent_conn(), {AppView, :app}) end end test "put_view/2 and put_new_view/2" do conn = put_new_view(conn(:get, "/"), Hello) assert view_module(conn) == Hello conn = put_new_view(conn, World) assert view_module(conn) == Hello conn = put_view(conn, World) assert view_module(conn) == World assert_raise Plug.Conn.AlreadySentError, fn -> put_new_view(sent_conn(), Hello) end assert_raise Plug.Conn.AlreadySentError, fn -> put_view(sent_conn(), Hello) end end test "put_view/2 and put_new_view/2 with formats" do conn = conn(:get, "/") |> put_format("print") |> put_new_view(html: Hello, json: HelloJSON) assert view_module(conn, "html") == Hello assert_raise RuntimeError, ~r/no view was found for the format: "print"/, fn -> view_module(conn) end conn = conn(:get, "/") |> put_format("html") |> put_new_view(html: Hello, json: HelloJSON) conn = put_format(conn, "html") assert view_module(conn) == Hello conn = put_new_view(conn, html: World) assert view_module(conn) == Hello conn = put_view(conn, html: World) assert view_module(conn) == World conn = put_format(conn, "json") assert view_module(conn) == HelloJSON assert view_module(conn, "json") == HelloJSON conn = put_format(conn, "json") conn = put_new_view(conn, Hello) assert view_module(conn) == Hello assert view_module(conn, "json") == Hello assert_raise Plug.Conn.AlreadySentError, fn -> put_new_view(sent_conn(), html: Hello) end assert_raise Plug.Conn.AlreadySentError, fn -> put_view(sent_conn(), html: Hello) end end describe "json/2" do test "encodes content to json" do conn = json(conn(:get, "/"), %{foo: :bar}) assert conn.resp_body == "{\"foo\":\"bar\"}" assert get_resp_content_type(conn) == "application/json" refute conn.halted end test "allows status injection on connection" do conn = conn(:get, "/") |> put_status(400) conn = json(conn, %{foo: :bar}) assert conn.resp_body == "{\"foo\":\"bar\"}" assert conn.status == 400 end test "allows content-type injection on connection" do conn = conn(:get, "/") |> put_resp_content_type("application/vnd.api+json") conn = json(conn, %{foo: :bar}) assert conn.resp_body == "{\"foo\":\"bar\"}" assert Conn.get_resp_header(conn, "content-type") == ["application/vnd.api+json; charset=utf-8"] end test "with allow_jsonp/2 returns json when no callback param is present" do conn = conn(:get, "/") |> fetch_query_params() |> allow_jsonp() |> json(%{foo: "bar"}) assert conn.resp_body == "{\"foo\":\"bar\"}" assert get_resp_content_type(conn) == "application/json" refute conn.halted end test "with allow_jsonp/2 returns json when callback name is left empty" do conn = conn(:get, "/?callback=") |> fetch_query_params() |> allow_jsonp() |> json(%{foo: "bar"}) assert conn.resp_body == "{\"foo\":\"bar\"}" assert get_resp_content_type(conn) == "application/json" refute conn.halted end test "with allow_jsonp/2 returns javascript when callback param is present" do conn = conn(:get, "/?callback=cb") |> fetch_query_params |> allow_jsonp |> json(%{foo: "bar"}) assert conn.resp_body == "/**/ typeof cb === 'function' && cb({\"foo\":\"bar\"});" assert get_resp_content_type(conn) == "application/javascript" refute conn.halted end test "with allow_jsonp/2 allows to override the callback param" do conn = conn(:get, "/?cb=cb") |> fetch_query_params |> allow_jsonp(callback: "cb") |> json(%{foo: "bar"}) assert conn.resp_body == "/**/ typeof cb === 'function' && cb({\"foo\":\"bar\"});" assert get_resp_content_type(conn) == "application/javascript" refute conn.halted end test "with allow_jsonp/2 raises ArgumentError when callback contains invalid characters" do conn = conn(:get, "/?cb=_c*b!()[0]") |> fetch_query_params() assert_raise ArgumentError, "the JSONP callback name contains invalid characters", fn -> allow_jsonp(conn, callback: "cb") end end test "with allow_jsonp/2 escapes invalid javascript characters" do conn = conn(:get, "/?cb=cb") |> fetch_query_params |> allow_jsonp(callback: "cb") |> json(%{foo: <<0x2028::utf8, 0x2029::utf8>>}) assert conn.resp_body == "/**/ typeof cb === 'function' && cb({\"foo\":\"\\u2028\\u2029\"});" assert get_resp_content_type(conn) == "application/javascript" refute conn.halted end end describe "text/2" do test "sends the content as text" do conn = text(conn(:get, "/"), "foobar") assert conn.resp_body == "foobar" assert get_resp_content_type(conn) == "text/plain" refute conn.halted conn = text(conn(:get, "/"), :foobar) assert conn.resp_body == "foobar" assert get_resp_content_type(conn) == "text/plain" refute conn.halted end test "allows status injection on connection" do conn = conn(:get, "/") |> put_status(400) conn = text(conn, :foobar) assert conn.resp_body == "foobar" assert conn.status == 400 end end describe "html/2" do test "sends the content as html" do conn = html(conn(:get, "/"), "foobar") assert conn.resp_body == "foobar" assert get_resp_content_type(conn) == "text/html" refute conn.halted end test "allows status injection on connection" do conn = conn(:get, "/") |> put_status(400) conn = html(conn, "foobar") assert conn.resp_body == "foobar" assert conn.status == 400 end end describe "redirect/2" do test "with :to" do conn = redirect(conn(:get, "/"), to: "/foobar") assert conn.resp_body =~ "/foobar" assert get_resp_content_type(conn) == "text/html" assert get_resp_header(conn, "location") == ["/foobar"] refute conn.halted conn = redirect(conn(:get, "/"), to: "/") assert conn.resp_body =~ "/<foobar>" assert_raise ArgumentError, ~r/the :to option in redirect expects a path/, fn -> redirect(conn(:get, "/"), to: "http://example.com") end assert_raise ArgumentError, ~r/the :to option in redirect expects a path/, fn -> redirect(conn(:get, "/"), to: "//example.com") end assert_raise ArgumentError, ~r/unsafe/, fn -> redirect(conn(:get, "/"), to: "/\\example.com") end assert_raise ArgumentError, ~r/expects a path/, fn -> redirect(conn(:get, "/"), to: "//\\example.com") end assert_raise ArgumentError, ~r/unsafe/, fn -> redirect(conn(:get, "/"), to: "/%09/example.com") end assert_raise ArgumentError, ~r/unsafe/, fn -> redirect(conn(:get, "/"), to: "/\t/example.com") end end test "with :external" do conn = redirect(conn(:get, "/"), external: "http://example.com") assert conn.resp_body =~ "http://example.com" assert get_resp_header(conn, "location") == ["http://example.com"] refute conn.halted end test "with put_status/2 uses previously set status or defaults to 302" do conn = conn(:get, "/") |> redirect(to: "/") assert conn.status == 302 conn = conn(:get, "/") |> put_status(301) |> redirect(to: "/") assert conn.status == 301 end end defp with_accept(header) do conn(:get, "/", []) |> put_req_header("accept", header) end describe "accepts/2" do test "uses params[\"_format\"] when available" do conn = accepts(conn(:get, "/", _format: "json"), ~w(json)) assert get_format(conn) == "json" assert conn.params["_format"] == "json" exception = assert_raise Phoenix.NotAcceptableError, ~r/unknown format "json"/, fn -> accepts(conn(:get, "/", _format: "json"), ~w(html)) end assert Plug.Exception.status(exception) == 406 assert exception.accepts == ["html"] end test "uses first accepts on empty or catch-all header" do conn = accepts(conn(:get, "/", []), ~w(json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("*/*"), ~w(json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil end test "uses first matching accepts on empty subtype" do conn = accepts(with_accept("text/*"), ~w(json text css)) assert get_format(conn) == "text" assert conn.params["_format"] == nil end test "on non-empty */*" do # Fallbacks to HTML due to browsers behavior conn = accepts(with_accept("application/json, */*"), ~w(html json)) assert get_format(conn) == "html" assert conn.params["_format"] == nil conn = accepts(with_accept("*/*, application/json"), ~w(html json)) assert get_format(conn) == "html" assert conn.params["_format"] == nil # No HTML is treated normally conn = accepts(with_accept("*/*, text/plain, application/json"), ~w(json text)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("text/plain, application/json, */*"), ~w(json text)) assert get_format(conn) == "text" assert conn.params["_format"] == nil conn = accepts(with_accept("text/*, application/*, */*"), ~w(json text)) assert get_format(conn) == "text" assert conn.params["_format"] == nil end test "ignores invalid media types" do conn = accepts(with_accept("foo/bar, bar baz, application/json"), ~w(html json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("foo/*, */bar, text/*"), ~w(json html)) assert get_format(conn) == "html" assert conn.params["_format"] == nil end test "considers q params" do conn = accepts(with_accept("text/html; q=0.7, application/json"), ~w(html json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("application/json, text/html; q=0.7"), ~w(html json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("application/json; q=1.0, text/html; q=0.7"), ~w(html json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("application/json; q=0.8, text/html; q=0.7"), ~w(html json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("text/html; q=0.7, application/json; q=0.8"), ~w(html json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("text/*; q=0.7, application/json"), ~w(html json)) assert get_format(conn) == "json" assert conn.params["_format"] == nil conn = accepts(with_accept("application/json; q=0.7, text/*; q=0.8"), ~w(json html)) assert get_format(conn) == "html" assert conn.params["_format"] == nil exception = assert_raise Phoenix.NotAcceptableError, ~r/no supported media type in accept/, fn -> accepts(with_accept("text/html; q=0.7, application/json; q=0.8"), ~w(xml)) end assert Plug.Exception.status(exception) == 406 assert exception.accepts == ["xml"] end end describe "send_download/3" do @hello_txt Path.expand("../../fixtures/hello.txt", __DIR__) test "sends file for download" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}) assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == ["attachment; filename=\"hello.txt\""] assert get_resp_header(conn, "content-type") == ["text/plain"] assert conn.resp_body == "world" end test "sends file for download with custom :filename" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, filename: "hello world.json") assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == [ "attachment; filename=\"hello%20world.json\"; filename*=utf-8''hello%20world.json" ] assert get_resp_header(conn, "content-type") == ["application/json"] assert conn.resp_body == "world" end test "sends file for download for filename with unreserved characters" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, filename: "hello, world.json") assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == [ "attachment; filename=\"hello%2C%20world.json\"; filename*=utf-8''hello%2C%20world.json" ] assert get_resp_header(conn, "content-type") == ["application/json"] assert conn.resp_body == "world" end test "sends file supports UTF-8" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, filename: "测 试.txt") assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == [ "attachment; filename=\"%E6%B5%8B%20%E8%AF%95.txt\"; filename*=utf-8''%E6%B5%8B%20%E8%AF%95.txt" ] assert get_resp_header(conn, "content-type") == ["text/plain"] assert conn.resp_body == "world" end test "sends file for download with custom :filename and :encode false" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, filename: "dev's hello world.json", encode: false ) assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == ["attachment; filename=\"dev's hello world.json\""] assert get_resp_header(conn, "content-type") == ["application/json"] assert conn.resp_body == "world" end test "sends file for download with custom :content_type and :charset" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, content_type: "application/json", charset: "utf8" ) assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == ["attachment; filename=\"hello.txt\""] assert get_resp_header(conn, "content-type") == ["application/json; charset=utf8"] assert conn.resp_body == "world" end test "sends file for download with custom :disposition" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, disposition: :inline) assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == ["inline; filename=\"hello.txt\""] assert conn.resp_body == "world" end test "sends file for download with custom :offset" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, offset: 2) assert conn.status == 200 assert conn.resp_body == "rld" end test "sends file for download with custom :length" do conn = send_download(conn(:get, "/"), {:file, @hello_txt}, length: 2) assert conn.status == 200 assert conn.resp_body == "wo" end test "sends binary for download with :filename" do conn = send_download(conn(:get, "/"), {:binary, "world"}, filename: "hello.json") assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == ["attachment; filename=\"hello.json\""] assert get_resp_header(conn, "content-type") == ["application/json"] assert conn.resp_body == "world" end test "sends binary as download with custom :content_type and :charset" do conn = send_download(conn(:get, "/"), {:binary, "world"}, filename: "hello.txt", content_type: "application/json", charset: "utf8" ) assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == ["attachment; filename=\"hello.txt\""] assert get_resp_header(conn, "content-type") == ["application/json; charset=utf8"] assert conn.resp_body == "world" end test "sends binary for download with custom :disposition" do conn = send_download(conn(:get, "/"), {:binary, "world"}, filename: "hello.txt", disposition: :inline ) assert conn.status == 200 assert get_resp_header(conn, "content-disposition") == ["inline; filename=\"hello.txt\""] assert conn.resp_body == "world" end test "raises ArgumentError for :disposition other than :attachment or :inline" do assert_raise( ArgumentError, ~r"expected :disposition to be :attachment or :inline, got: :foo", fn -> send_download(conn(:get, "/"), {:file, @hello_txt}, disposition: :foo) end ) assert_raise( ArgumentError, ~r"expected :disposition to be :attachment or :inline, got: :foo", fn -> send_download(conn(:get, "/"), {:binary, "world"}, filename: "hello.txt", disposition: :foo ) end ) end end describe "scrub_params/2" do test "raises Phoenix.MissingParamError for missing key" do assert_raise( Phoenix.MissingParamError, ~r"expected key \"foo\" to be present in params", fn -> conn(:get, "/") |> fetch_query_params |> scrub_params("foo") end ) assert_raise( Phoenix.MissingParamError, ~r"expected key \"foo\" to be present in params", fn -> conn(:get, "/?foo=") |> fetch_query_params |> scrub_params("foo") end ) end test "keeps populated keys intact" do conn = conn(:get, "/?foo=bar") |> fetch_query_params |> scrub_params("foo") assert conn.params["foo"] == "bar" end test "nils out all empty values for the passed in key if it is a list" do conn = conn(:get, "/?foo[]=&foo[]=++&foo[]=bar") |> fetch_query_params |> scrub_params("foo") assert conn.params["foo"] == [nil, nil, "bar"] end test "nils out all empty keys in value for the passed in key if it is a map" do conn = conn(:get, "/?foo[bar]=++&foo[baz]=&foo[bat]=ok") |> fetch_query_params |> scrub_params("foo") assert conn.params["foo"] == %{"bar" => nil, "baz" => nil, "bat" => "ok"} end test "nils out all empty keys in value for the passed in key if it is a nested map" do conn = conn(:get, "/?foo[bar][baz]=") |> fetch_query_params |> scrub_params("foo") assert conn.params["foo"] == %{"bar" => %{"baz" => nil}} end test "ignores the keys that don't match the passed in key" do conn = conn(:get, "/?foo=bar&baz=") |> fetch_query_params |> scrub_params("foo") assert conn.params["baz"] == "" end test "keeps structs intact" do conn = conn(:post, "/", %{"foo" => %{"bar" => %Plug.Upload{}}}) |> fetch_query_params |> scrub_params("foo") assert conn.params["foo"]["bar"] == %Plug.Upload{} end end test "protect_from_forgery/2 sets token" do conn(:get, "/") |> init_test_session(%{}) |> protect_from_forgery([]) assert is_binary(get_csrf_token()) assert is_binary(delete_csrf_token()) end describe "put_secure_browser_headers/2" do test "sets headers" do conn = conn(:get, "/") |> put_secure_browser_headers() assert get_resp_header(conn, "x-content-type-options") == ["nosniff"] assert get_resp_header(conn, "x-permitted-cross-domain-policies") == ["none"] assert get_resp_header(conn, "content-security-policy") == ["base-uri 'self'; frame-ancestors 'self';"] end test "only if not set headers" do custom_headers = %{"content-security-policy" => "custom", "foo" => "bar"} conn = conn(:get, "/") |> merge_resp_headers(custom_headers) |> put_secure_browser_headers() assert get_resp_header(conn, "x-content-type-options") == ["nosniff"] assert get_resp_header(conn, "x-permitted-cross-domain-policies") == ["none"] assert get_resp_header(conn, "content-security-policy") == ["custom"] assert get_resp_header(conn, "foo") == ["bar"] end test "can be overridden" do custom_headers = %{"content-security-policy" => "custom", "foo" => "bar"} conn = conn(:get, "/") |> put_secure_browser_headers(custom_headers) assert get_resp_header(conn, "x-content-type-options") == ["nosniff"] assert get_resp_header(conn, "x-permitted-cross-domain-policies") == ["none"] assert get_resp_header(conn, "content-security-policy") == ["custom"] assert get_resp_header(conn, "foo") == ["bar"] end end describe "__using__" do defp new_layout(module, opts), do: Phoenix.Controller.__plugs__(module, opts) |> elem(0) defp new_view(module, opts), do: Phoenix.Controller.__plugs__(module, opts) |> elem(1) test "deprecated when lacking formats" do assert capture_io(:stderr, fn -> assert Phoenix.Controller.__plugs__(UserController, []) == {{LayoutView, :app}, UserView} end) =~ "use UserController must receive the :formats option with the formats you intend to render" assert capture_io(:stderr, fn -> assert Phoenix.Controller.__plugs__(MyApp.UserController, []) == {{MyApp.LayoutView, :app}, MyApp.UserView} end) =~ "use MyApp.UserController must receive the :formats option with the formats you intend to render" assert capture_io(:stderr, fn -> assert Phoenix.Controller.__plugs__(MyApp.Admin.UserController, []) == {{MyApp.LayoutView, :app}, MyApp.Admin.UserView} end) =~ "use MyApp.Admin.UserController must receive the :formats option with the formats you intend to render" end test "deprecated namespace" do assert capture_io(:stderr, fn -> assert new_layout(MyApp.Admin.UserController, namespace: MyApp.Admin, formats: []) == {MyApp.Admin.LayoutView, :app} end) =~ "the :namespace option given to MyApp.Admin.UserController is deprecated" end test "returns view modules based on format" do assert new_view(MyApp.Admin.UserController, formats: [:html, :json]) == [html: MyApp.Admin.UserHTML, json: MyApp.Admin.UserJSON] assert new_view(MyApp.Admin.UserController, formats: [:html, json: "View"]) == [html: MyApp.Admin.UserHTML, json: MyApp.Admin.UserView] end test "returns the layout module based on controller module" do assert new_layout(MyApp.Admin.UserController, formats: []) == [] assert new_layout(MyApp.Admin.UserController, layouts: [html: MyApp.LayoutHTML], formats: [] ) == [html: {MyApp.LayoutHTML, :app}] assert new_layout(MyApp.Admin.UserController, layouts: [html: {MyApp.LayoutHTML, :application}], formats: [] ) == [html: {MyApp.LayoutHTML, :application}] end end defp sent_conn do conn(:get, "/") |> send_resp(:ok, "") end describe "path and url generation" do def url(), do: "https://www.example.com" def build_conn_for_path(path) do conn(:get, path) |> fetch_query_params() |> put_private(:phoenix_endpoint, __MODULE__) |> put_private(:phoenix_router, __MODULE__) end test "current_path/1 uses the conn's query params" do conn = build_conn_for_path("/") assert current_path(conn) == "/" conn = build_conn_for_path("/foo?one=1&two=2") assert current_path(conn) == "/foo?one=1&two=2" conn = build_conn_for_path("/foo//bar/") assert current_path(conn) == "/foo/bar" end test "current_path/2 allows custom query params" do conn = build_conn_for_path("/") assert current_path(conn, %{}) == "/" conn = build_conn_for_path("/foo?one=1&two=2") assert current_path(conn, %{}) == "/foo" conn = build_conn_for_path("/foo?one=1&two=2") assert current_path(conn, %{three: 3}) == "/foo?three=3" end test "current_path/2 allows custom nested query params" do conn = build_conn_for_path("/") assert current_path(conn, foo: [bar: [:baz], baz: :qux]) == "/?foo[bar][]=baz&foo[baz]=qux" end test "current_url/1 with root path includes trailing slash" do conn = build_conn_for_path("/") assert current_url(conn) == "https://www.example.com/" end test "current_url/1 users conn's endpoint and query params" do conn = build_conn_for_path("/?foo=bar") assert current_url(conn) == "https://www.example.com/?foo=bar" conn = build_conn_for_path("/foo?one=1&two=2") assert current_url(conn) == "https://www.example.com/foo?one=1&two=2" end test "current_url/2 allows custom query params" do conn = build_conn_for_path("/") assert current_url(conn, %{}) == "https://www.example.com/" conn = build_conn_for_path("/foo?one=1&two=2") assert current_url(conn, %{}) == "https://www.example.com/foo" conn = build_conn_for_path("/foo?one=1&two=2") assert current_url(conn, %{three: 3}) == "https://www.example.com/foo?three=3" end end describe "assign/2" do test "merges assigns" do conn = conn(:get, "/") refute conn.assigns[:foo] conn = assign(conn, %{foo: :bar}) assert conn.assigns.foo == :bar conn = assign(conn, bar: :baz) assert conn.assigns.foo == :bar assert conn.assigns.bar == :baz conn = assign(conn, fn %{foo: :bar} -> [baz: :quux] end) assert conn.assigns.foo == :bar assert conn.assigns.bar == :baz assert conn.assigns.baz == :quux end end end ================================================ FILE: test/phoenix/controller/flash_test.exs ================================================ defmodule Phoenix.Controller.FlashTest do use ExUnit.Case, async: true use RouterHelper import Phoenix.Controller alias Phoenix.Flash setup do Logger.put_process_level(self(), :none) :ok end @session Plug.Session.init( store: :cookie, key: "_app", encryption_salt: "yadayada", signing_salt: "yadayada" ) def with_session(conn) do conn |> Map.put(:secret_key_base, String.duplicate("abcdefgh", 8)) |> Plug.Session.call(@session) |> Plug.Conn.fetch_session() end test "does not fetch flash twice" do expected_flash = %{"foo" => "bar"} conn = conn(:get, "/") |> with_session() |> put_session("phoenix_flash", expected_flash) |> fetch_flash() |> put_session("phoenix_flash", %{"foo" => "baz"}) |> fetch_flash() assert conn.assigns.flash == expected_flash assert conn.assigns.flash == expected_flash end test "flash is persisted when status is a redirect" do for status <- 300..308 do conn = conn(:get, "/") |> with_session |> fetch_flash() |> put_flash(:notice, "elixir") |> send_resp(status, "ok") assert Flash.get(conn.assigns.flash, :notice) == "elixir" assert get_resp_header(conn, "set-cookie") != [] conn = conn(:get, "/") |> recycle_cookies(conn) |> with_session |> fetch_flash() assert Flash.get(conn.assigns.flash, :notice) == "elixir" end end test "flash is not persisted when status is not redirect" do for status <- [299, 309, 200, 404] do conn = conn(:get, "/") |> with_session |> fetch_flash() |> put_flash(:notice, "elixir") |> send_resp(status, "ok") assert Flash.get(conn.assigns.flash, :notice) == "elixir" assert get_resp_header(conn, "set-cookie") != [] conn = conn(:get, "/") |> recycle_cookies(conn) |> with_session |> fetch_flash() assert Flash.get(conn.assigns.flash, :notice) == nil end end test "flash does not write to session when it is empty and no session exists" do conn = conn(:get, "/") |> with_session() |> fetch_flash() |> clear_flash() |> send_resp(302, "ok") assert get_resp_header(conn, "set-cookie") == [] end test "flash writes to session when it is empty and a previous session exists" do persisted_flash_conn = conn(:get, "/") |> with_session() |> fetch_flash() |> put_flash(:info, "existing") |> send_resp(302, "ok") conn = conn(:get, "/") |> Plug.Test.recycle_cookies(persisted_flash_conn) |> with_session() |> fetch_flash() |> clear_flash() |> send_resp(200, "ok") assert ["_app=" <> _] = get_resp_header(conn, "set-cookie") end test "flash assigns contains the map of messages" do conn = conn(:get, "/") |> with_session |> fetch_flash([]) |> put_flash(:notice, "hi") assert conn.assigns.flash == %{"notice" => "hi"} end test "Flash.get/2 returns the message by key" do conn = conn(:get, "/") |> with_session |> fetch_flash([]) |> put_flash(:notice, "hi") assert Flash.get(conn.assigns.flash, :notice) == "hi" assert Flash.get(conn.assigns.flash, "notice") == "hi" end test "Flash.get/2 returns nil for missing key" do conn = conn(:get, "/") |> with_session |> fetch_flash([]) assert Flash.get(conn.assigns.flash, :notice) == nil assert Flash.get(conn.assigns.flash, "notice") == nil end test "put_flash/3 raises ArgumentError when flash not previously fetched" do assert_raise ArgumentError, fn -> conn(:get, "/") |> with_session |> put_flash(:error, "boom!") end end test "put_flash/3 adds the key/message pair to the flash and updates assigns" do conn = conn(:get, "/") |> with_session |> fetch_flash([]) assert conn.assigns.flash == %{} conn = conn |> put_flash(:error, "oh noes!") |> put_flash(:notice, "false alarm!") assert conn.assigns.flash == %{"error" => "oh noes!", "notice" => "false alarm!"} assert Flash.get(conn.assigns.flash, :error) == "oh noes!" assert Flash.get(conn.assigns.flash, "error") == "oh noes!" assert Flash.get(conn.assigns.flash, :notice) == "false alarm!" assert Flash.get(conn.assigns.flash, "notice") == "false alarm!" end test "clear_flash/1 clears the flash messages" do conn = conn(:get, "/") |> with_session |> fetch_flash([]) |> put_flash(:error, "oh noes!") |> put_flash(:notice, "false alarm!") refute conn.assigns.flash == %{} conn = clear_flash(conn) assert conn.assigns.flash == %{} end test "merge_flash/2 adds kv-pairs to the flash" do conn = conn(:get, "/") |> with_session |> fetch_flash([]) |> merge_flash(error: "oh noes!", notice: "false alarm!") assert Flash.get(conn.assigns.flash, :error) == "oh noes!" assert Flash.get(conn.assigns.flash, "error") == "oh noes!" assert Flash.get(conn.assigns.flash, :notice) == "false alarm!" assert Flash.get(conn.assigns.flash, "notice") == "false alarm!" end test "fetch_flash/2 raises ArgumentError when session not previously fetched" do assert_raise ArgumentError, fn -> conn(:get, "/") |> fetch_flash([]) end end describe "Flash" do test "get/2" do assert Flash.get(%{}, :info) == nil assert Flash.get(%{"info" => "hi"}, :info) == "hi" assert Flash.get(%{"info" => "hi", "error" => "ohno"}, :error) == "ohno" end test "invalid access" do assert_raise ArgumentError, ~r/expected a map of flash data, but got a %Plug.Conn{}/, fn -> Flash.get(%Plug.Conn{}, :info) end end end end ================================================ FILE: test/phoenix/controller/pipeline_test.exs ================================================ defmodule Phoenix.Controller.PipelineTest do use ExUnit.Case, async: true use RouterHelper import Phoenix.Controller defmodule MyController do use Phoenix.Controller, formats: [] @secret_actions [:secret] plug :prepend, :before1 when action in [:show, :create, :secret] plug :prepend, :before2 plug :do_halt when action in @secret_actions # Delete the attribute to verify attributes in guards are expanded at call time Module.delete_attribute(__MODULE__, :secret_actions) def show(conn, _) do prepend(conn, :action) end def no_fallback(_conn, _) do :not_a_conn end def create(conn, _) do prepend(conn, :action) end def secret(conn, _) do prepend(conn, :secret_action) end def no_match(_conn, %{"no" => "match"}) do raise "shouldn't have matched" end def non_top_level_function_clause_error(conn, params) do send_resp(conn, :ok, trigger_func_clause_error(params)) end defp trigger_func_clause_error(%{"no" => "match"}), do: "shouldn't ever match" defp do_halt(conn, _), do: halt(conn) defp prepend(conn, val) do update_in(conn.private.stack, &[val | &1]) end end defmodule NoViewsController do use Phoenix.Controller, formats: [] def show(conn, _), do: conn end defmodule FallbackFunctionController do use Phoenix.Controller, formats: [] action_fallback :function_plug plug :put_assign def fallback(_conn, _), do: :not_a_conn def bad_fallback(_conn, _), do: :bad_fallback defp function_plug(%Plug.Conn{} = conn, :not_a_conn) do Plug.Conn.send_resp(conn, 200, "function fallback") end defp function_plug(%Plug.Conn{}, :bad_fallback), do: :bad_function_fallback defp put_assign(conn, _), do: assign(conn, :value_before_action, :a_value) end defmodule ActionController do use Phoenix.Controller, formats: [] action_fallback Phoenix.Controller.PipelineTest plug :put_assign def action(conn, _) do apply(__MODULE__, conn.private.phoenix_action, [conn, conn.body_params, conn.query_params]) end def show(conn, _, _), do: text(conn, "show") def no_match(_conn, _, %{"no" => "match"}) do raise "Shouldn't have matched" end def fallback(_conn, _, _) do :not_a_conn end def bad_fallback(_conn, _, _) do :bad_fallback end defp put_assign(conn, _), do: assign(conn, :value_before_action, :a_value) end def init(opts), do: opts def call(conn, :not_a_conn), do: Plug.Conn.send_resp(conn, 200, "fallback") def call(_conn, :bad_fallback), do: :bad_fallback setup do Logger.put_process_level(self(), :none) :ok end test "invokes the plug stack" do conn = stack_conn() |> MyController.call(:show) assert conn.private.stack == [:action, :before2, :before1] end test "invokes the plug stack with guards" do conn = stack_conn() |> MyController.call(:create) assert conn.private.stack == [:action, :before2, :before1] end test "halts prevent action from running" do conn = stack_conn() |> MyController.call(:secret) assert conn.private.stack == [:before2, :before1] end test "does not override previous views/layouts" do conn = stack_conn() |> put_view(Hello) |> put_layout(false) |> MyController.call(:create) assert view_module(conn) == Hello assert layout(conn) == false end test "does not set default view/layout" do conn = stack_conn() |> NoViewsController.call(:show) |> put_new_view(Hello) assert view_module(conn) == Hello assert layout(conn) == false end test "transforms top-level function clause errors into Phoenix.ActionClauseError" do assert_raise Phoenix.ActionClauseError, fn -> MyController.call(stack_conn(), :no_match) end end test "wraps function clause errors lower in action stack in Plug.Conn.WrapperError" do assert_raise Plug.Conn.WrapperError, fn -> MyController.call(stack_conn(), :non_top_level_function_clause_error) end end test "action/2 is overridable and still wraps function clause transforms" do conn = ActionController.call(stack_conn(), :show) assert conn.status == 200 assert conn.resp_body == "show" assert_raise Phoenix.ActionClauseError, fn -> ActionController.call(stack_conn(), :no_match) end end describe "action_fallback" do test "module fallback delegates to plug for bad return values when not configured" do assert_raise RuntimeError, ~r/expected action\/2 to return a Plug.Conn/, fn -> MyController.call(stack_conn(), :no_fallback) end end test "module fallback invokes module plug when configured" do conn = ActionController.call(stack_conn(), :fallback) assert conn.status == 200 assert conn.assigns.value_before_action == :a_value assert conn.resp_body == "fallback" end test "module fallback with bad return delegates to plug" do assert_raise RuntimeError, ~r/expected action\/2 to return a Plug.Conn/, fn -> ActionController.call(stack_conn(), :bad_fallback) end end test "function fallback invokes module plug when configured" do conn = FallbackFunctionController.call(stack_conn(), :fallback) assert conn.status == 200 assert conn.assigns.value_before_action == :a_value assert conn.resp_body == "function fallback" end test "function fallback with bad return delegates to plug" do assert_raise RuntimeError, ~r/expected action\/2 to return a Plug.Conn/, fn -> FallbackFunctionController.call(stack_conn(), :bad_fallback) end end test "raises when calling from import instead of use", config do assert_raise RuntimeError, ~r/can only be called when using Phoenix.Controller/, fn -> defmodule config.test do import Phoenix.Controller action_fallback Boom end end end test "raises when calling more than once", config do assert_raise RuntimeError, ~r/can only be called a single time/, fn -> defmodule config.test do use Phoenix.Controller, formats: [] action_fallback Ok action_fallback Boom end end end end defp stack_conn() do conn(:get, "/") |> fetch_query_params() |> put_private(:stack, []) end end ================================================ FILE: test/phoenix/controller/render_test.exs ================================================ Code.require_file("../../fixtures/views.exs", __DIR__) defmodule Phoenix.Controller.RenderTest do use ExUnit.Case, async: true use RouterHelper import Phoenix.Controller defp conn() do conn(:get, "/") |> fetch_query_params() |> put_view(MyApp.UserView) end defp layout_conn() do conn() |> put_layout({MyApp.LayoutView, :app}) end defp html_response?(conn) do assert get_resp_header(conn, "content-type") == ["text/html; charset=utf-8"] end test "renders string template" do conn = render(conn(), "index.html", title: "Hello") assert conn.resp_body == "Hello\n" assert html_response?(conn) refute conn.halted assert view_template(conn) == "index.html" end test "renders atom template" do conn = put_format(conn(), "html") conn = render(conn, :index, title: "Hello") assert conn.resp_body == "Hello\n" assert html_response?(conn) refute conn.halted assert view_template(conn) == "index.html" end test "renders string template with put layout" do conn = render(layout_conn(), "index.html", title: "Hello") assert conn.resp_body =~ ~r"Hello" assert html_response?(conn) end test "renders string template with put_root_layout" do conn = conn() |> put_layout({MyApp.LayoutView, "app.html"}) |> put_root_layout({MyApp.LayoutView, "root.html"}) |> render("index.html", title: "Hello") assert conn.resp_body == "ROOTSTART[Hello]\n Hello\n Hello\n\n\nROOTEND\n" assert html_response?(conn) end test "renders atom template with put layout" do conn = put_format(layout_conn(), "html") conn = render(conn, :index, title: "Hello") assert conn.resp_body =~ ~r"Hello" assert html_response?(conn) end test "renders atom template with put_root_layout" do conn = conn() |> put_layout({MyApp.LayoutView, "app.html"}) |> put_root_layout({MyApp.LayoutView, :root}) |> render("index.html", title: "Hello") assert conn.resp_body == "ROOTSTART[Hello]\n Hello\n Hello\n\n\nROOTEND\n" assert html_response?(conn) end test "renders template with overriding layout option" do conn = render(layout_conn(), "index.html", title: "Hello", layout: false) assert conn.resp_body == "Hello\n" assert html_response?(conn) end test "renders template with atom layout option" do conn = render(conn(), "index.html", title: "Hello", layout: {MyApp.LayoutView, :app}) assert conn.resp_body =~ ~r"Hello" assert html_response?(conn) end test "renders template with string layout option" do conn = render(conn(), "index.html", title: "Hello", layout: {MyApp.LayoutView, "app.html"}) assert conn.resp_body =~ ~r"Hello" assert html_response?(conn) end test "render with layout sets view_module/template for layout and inner view" do conn = render(conn(), "inner.html", title: "Hello", layout: {MyApp.LayoutView, :app}) assert conn.resp_body == "\n Hello\n View module is Elixir.MyApp.UserView and view template is inner.html\n\n\n" end test "render without layout sets inner view_module/template assigns" do conn = render(conn(), "inner.html", []) assert conn.resp_body == "View module is Elixir.MyApp.UserView and view template is inner.html\n" end test "renders with conn status code" do conn = %{conn() | status: 404} conn = render(conn, "index.html", title: "Hello", layout: {MyApp.LayoutView, "app.html"}) assert conn.status == 404 end test "merges render assigns" do conn = render(conn(), "index.html", title: "Hello") assert conn.resp_body == "Hello\n" assert conn.assigns.title == "Hello" end test "uses connection assigns" do conn = conn() |> assign(:title, "Hello") |> render("index.html") assert conn.resp_body == "Hello\n" assert html_response?(conn) end test "uses custom status" do conn = render(conn(), "index.html", title: "Hello") assert conn.status == 200 conn = render(put_status(conn(), :created), "index.html", title: "Hello") assert conn.status == 201 end test "uses action name" do conn = put_format(conn(), "html") conn = put_in(conn.private[:phoenix_action], :index) conn = render(conn, title: "Hello") assert conn.resp_body == "Hello\n" end test "render/2 renders with View and Template with atom for template" do conn = put_format(conn(), "json") conn = put_in(conn.private[:phoenix_action], :show) conn = put_view(conn, MyApp.UserView) conn = render(conn, :show) assert conn.resp_body == ~s({"foo":"bar"}) end test "render/2 renders with View and Template" do conn = put_format(conn(), "json") conn = put_in(conn.private[:phoenix_action], :show) conn = put_view(conn, MyApp.UserView) conn = render(conn, "show.json") assert conn.resp_body == ~s({"foo":"bar"}) end test "errors when rendering without format" do assert_raise RuntimeError, ~r/cannot render template :index because conn.params/, fn -> render(conn(), :index) end assert_raise RuntimeError, ~r/cannot render template "index" without format/, fn -> render(conn(), "index") end end test "errors when rendering without view" do assert_raise RuntimeError, ~r/no view was found for the format: "html"/, fn -> render(conn() |> put_view(nil), "index.html") end end describe "telemetry" do @render_start_event [:phoenix, :controller, :render, :start] @render_stop_event [:phoenix, :controller, :render, :stop] @render_exception_event [:phoenix, :controller, :render, :exception] @render_events [ @render_start_event, @render_stop_event, @render_exception_event ] setup context do :telemetry.attach_many(context.test, @render_events, &__MODULE__.message_pid/4, self()) on_exit(fn -> :telemetry.detach(context.test) end) end def message_pid(event, measures, metadata, test_pid) do send(test_pid, {:telemetry_event, event, {measures, metadata}}) end test "phoenix.controller.render.start and .stop are emitted on success" do render(conn(), "index.html", title: "Hello") assert_received {:telemetry_event, [:phoenix, :controller, :render, :start], {_, %{format: "html", template: "index", view: MyApp.UserView}}} assert_received {:telemetry_event, [:phoenix, :controller, :render, :stop], {_, %{format: "html", template: "index", view: MyApp.UserView}}} refute_received {:telemetry_event, [:phoenix, :controller, :render, :exception], _} end test "phoenix.controller.render.exception is emitted on failure" do :ok = try do render(conn(), "index.html") rescue ArgumentError -> :ok end assert_received {:telemetry_event, [:phoenix, :controller, :render, :start], {_, %{format: "html", template: "index", view: MyApp.UserView}}} refute_received {:telemetry_event, [:phoenix, :controller, :render, :stop], _} assert_received {:telemetry_event, [:phoenix, :controller, :render, :exception], {_, %{ format: "html", template: "index", view: MyApp.UserView, kind: :error, reason: %ArgumentError{} }}} end end end ================================================ FILE: test/phoenix/debug_test.exs ================================================ defmodule Phoenix.DebugTest do use ExUnit.Case, async: true alias Phoenix.Debug # we cannot easily test the Phoenix.Debug functions with the regular # Phoenix.ChannelTest functions, because they use the test process # itself as the transport process defmodule FakeSocket do use GenServer def init(channel_pid) do Process.put(:"$process_label", {Phoenix.Socket, __MODULE__, nil}) {:ok, channel_pid} end def handle_info({:debug_channels, ref, reply_to}, state) do send( reply_to, {:debug_channels, ref, [%{pid: state, status: :joined, topic: "room:lobby"}]} ) {:noreply, state} end end defmodule FakeChannel do use GenServer def init(state) do Process.put(:"$process_label", {Phoenix.Channel, __MODULE__.Channel, "room:lobby"}) {:ok, state} end def handle_call(:socket, _from, state) do {:reply, %Phoenix.Socket{}, state} end end setup do {:ok, channel_pid} = GenServer.start_link(FakeChannel, nil) {:ok, socket_pid} = GenServer.start_link(FakeSocket, channel_pid) %{socket_pid: socket_pid, channel_pid: channel_pid} end describe "list_sockets/0" do test "returns a list of all currently connected channel socket processes", %{ socket_pid: socket_pid } do sockets = Debug.list_sockets() assert is_list(sockets) assert Enum.any?(sockets, fn s -> s.pid == socket_pid end) assert Enum.find(sockets, fn s -> s.module == __MODULE__.FakeSocket end) end end describe "socket_process?/1" do test "returns true if the given pid is a channel socket process", %{socket_pid: socket_pid} do assert Debug.socket_process?(socket_pid) end test "returns false for a non-socket process" do refute Debug.socket_process?(self()) end end describe "channel_process?/1" do test "returns true if the given pid is a channel process", %{channel_pid: channel_pid} do assert Debug.channel_process?(channel_pid) end test "returns false for a non-channel process" do refute Debug.channel_process?(self()) end end describe "list_channels/1" do test "returns a list of all channels for a given socket pid", %{ socket_pid: socket_pid, channel_pid: channel_pid } do {:ok, channels} = Debug.list_channels(socket_pid) assert is_list(channels) assert Enum.any?(channels, fn ch -> ch.pid == channel_pid and ch.topic == "room:lobby" end) end test "returns error for non-socket pid" do assert {:error, :not_alive} = Debug.list_channels(self()) end end describe "socket/1" do test "returns the socket struct for a channel process", %{channel_pid: channel_pid} do assert {:ok, %Phoenix.Socket{}} = Debug.socket(channel_pid) end test "returns error for non-channel process" do assert {:error, :not_alive_or_not_a_channel} = Debug.socket(self()) end end end ================================================ FILE: test/phoenix/digester/gzip_test.exs ================================================ defmodule Phoenix.Digester.GzipTest do use ExUnit.Case, async: true alias Phoenix.Digester.Gzip test "compress_file/2 compresses file" do file_path = "test/fixtures/digest/priv/static/css/app.css" content = File.read!(file_path) {:ok, compressed} = Gzip.compress_file(file_path, content) assert is_binary(compressed) end end ================================================ FILE: test/phoenix/digester_test.exs ================================================ defmodule Phoenix.DigesterTest do use ExUnit.Case, async: true @output_path Path.join("tmp", "phoenix_digest") @fake_now 32_132_173 @hash_regex ~S"[a-fA-F\d]{32}" defmodule DigestTestCompressor do @behaviour Phoenix.Digester.Compressor def compress_file(_file_path, _content), do: :error def file_extensions, do: [".digest_test"] end setup do File.rm_rf!(@output_path) on_exit(fn -> File.rm_rf!(@output_path) end) :ok end describe "compile" do test "fails when the given paths are invalid" do assert {:error, :invalid_path} = Phoenix.Digester.compile("nonexistent path", "/ ?? /path", true) end test "digests and compress files" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) output_files = assets_files(@output_path) assert "phoenix.png" in output_files refute "phoenix.png.gz" in output_files assert "app.js" in output_files assert "app.js.gz" in output_files assert "app.js.map" in output_files assert "app.js.map.gz" in output_files assert "css/app.css" in output_files assert "css/app.css.gz" in output_files assert "manifest.json" in output_files assert "manifest.json.gz" in output_files assert "cache_manifest.json" in output_files assert Enum.any?(output_files, &String.match?(&1, ~r/(phoenix-#{@hash_regex}\.png)/)) refute Enum.any?(output_files, &String.match?(&1, ~r/(phoenix-#{@hash_regex}\.png\.gz)/)) json = Path.join(@output_path, "cache_manifest.json") |> json_read!() assert json["latest"]["phoenix.png"] =~ ~r"phoenix-#{@hash_regex}.png" assert json["version"] == 1 end test "includes existing digests in new cache manifest" do source_path = "test/fixtures/digest/priv/static/" input_path = "tmp/digest/static" File.rm_rf!(input_path) :ok = File.mkdir_p!(@output_path) :ok = File.mkdir_p!(input_path) {:ok, _} = File.cp_r(source_path, input_path) :ok = File.cp( Path.join(source_path, "foo.css"), Path.join(@output_path, "foo-d978852bea6530fcd197b5445ed008fd.css") ) :ok = File.cp( "test/fixtures/digest/compile/cache_manifest.json", Path.join(@output_path, "cache_manifest.json") ) assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) json = Path.join(@output_path, "cache_manifest.json") |> json_read!() # Keep old entries assert json["digests"]["foo-d978852bea6530fcd197b5445ed008fd.css"]["logical_path"] == "foo.css" # Update mtime assert_in_delta json["digests"]["foo-d978852bea6530fcd197b5445ed008fd.css"]["mtime"], now(), 2 # Add new entries key = Enum.find(Map.keys(json["digests"]), &(&1 =~ ~r"phoenix-#{@hash_regex}.png")) assert json["version"] == 1 assert is_integer(json["digests"][key]["mtime"]) assert json["digests"][key]["logical_path"] == "phoenix.png" assert json["digests"][key]["size"] == 13900 assert json["digests"][key]["digest"] =~ ~r"#{@hash_regex}" assert json["digests"][key]["sha512"] == "93pY5dBa8nHHi0Zfj75O/vXCBXb+UvEVCyU7Yd3pzOJ7o1wkYBWbvs3pVXhBChEmo8MDANT11vsggo2+bnYqoQ==" after File.rm_rf!("tmp/digest") end test "excludes compiled files" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) output_files = assets_files(@output_path) json = Path.join(@output_path, "cache_manifest.json") |> json_read!() refute json["latest"]["precompressed.js.gz"] assert :ok = Phoenix.Digester.compile(@output_path, @output_path, true) assert output_files == assets_files(@output_path) end test "old versions maintain their mtime" do source_path = "test/fixtures/digest/priv/static/" input_path = "tmp/digest/static" File.rm_rf!(input_path) :ok = File.mkdir_p!(@output_path) :ok = File.mkdir_p!(input_path) :ok = File.cp( Path.join(source_path, "foo.css"), Path.join(@output_path, "foo-d978852bea6530fcd197b5445ed008fd.css") ) :ok = File.cp( "test/fixtures/digest/compile/cache_manifest.json", Path.join(@output_path, "cache_manifest.json") ) File.write!(Path.join(input_path, "foo.css"), ".foo { background-color: blue }") assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) json = Path.join(@output_path, "cache_manifest.json") |> json_read!() assert json["digests"]["foo-d978852bea6530fcd197b5445ed008fd.css"]["mtime"] == 32_132_171 assert_in_delta json["digests"]["foo-1198fd3c7ecf0e8f4a33a6e4fc5ae168.css"]["mtime"], now(), 2 after File.rm_rf!("tmp/digest") end test "excludes files that no longer exist from cache manifest" do input_path = "tmp/digest/static" File.rm_rf!(input_path) :ok = File.mkdir_p!(input_path) :ok = File.cp( "test/fixtures/digest/compile/cache_manifest.json", Path.join(input_path, "cache_manifest.json") ) assert :ok = Phoenix.Digester.compile(input_path, input_path, true) json = Path.join(input_path, "cache_manifest.json") |> json_read!() assert json["digests"] == %{} after File.rm_rf!("tmp/digest") end test "digests and compress nested files" do input_path = "test/fixtures/digest/priv/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) output_files = assets_files(@output_path) assert "static/phoenix.png" in output_files refute "static/phoenix.png.gz" in output_files assert "cache_manifest.json" in output_files assert Enum.any?(output_files, &String.match?(&1, ~r/(phoenix-#{@hash_regex}\.png)/)) refute Enum.any?(output_files, &String.match?(&1, ~r/(phoenix-#{@hash_regex}\.png\.gz)/)) json = Path.join(@output_path, "cache_manifest.json") |> json_read!() assert json["latest"]["static/phoenix.png"] =~ ~r"static/phoenix-#{@hash_regex}\.png" end test "keeps old version in cache manifest when digesting twice" do input_path = Path.join("tmp", "phoenix_digest_twice") input_file = Path.join(input_path, "file.js") try do File.rm_rf!(input_path) File.mkdir_p!(input_path) File.mkdir_p!(@output_path) File.write!(input_file, "console.log('test');") assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) json1 = Path.join(@output_path, "cache_manifest.json") |> json_read!() assert Enum.count(json1["digests"]) == 1 File.write!(input_file, "console.log('test2');") assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) json2 = Path.join(@output_path, "cache_manifest.json") |> json_read!() assert Enum.count(json2["digests"]) == 2 after File.rm_rf!(input_path) end end test "doesn't duplicate files when digesting and compressing twice" do input_path = Path.join("tmp", "phoenix_digest_twice") input_file = Path.join(input_path, "file.js") try do File.rm_rf!(input_path) File.mkdir_p!(input_path) File.write!(input_file, "console.log('test');") assert :ok = Phoenix.Digester.compile(input_path, input_path, true) assert :ok = Phoenix.Digester.compile(input_path, input_path, true) output_files = assets_files(input_path) refute "file.js.gz.gz" in output_files refute "cache_manifest.json.gz" in output_files refute Enum.any?(output_files, &(&1 =~ ~r/file-#{@hash_regex}.[\w|\d]*.[-#{@hash_regex}/)) after File.rm_rf!(input_path) end end test "digests only absolute and relative asset paths found within stylesheets with vsn" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) digested_css_filename = assets_files(@output_path) |> Enum.find(&(&1 =~ ~r"app-#{@hash_regex}.css")) digested_css = Path.join(@output_path, digested_css_filename) |> File.read!() refute digested_css =~ ~r"/phoenix\.png" refute digested_css =~ ~r"\.\./images/relative\.png" assert digested_css =~ ~r"/phoenix-#{@hash_regex}\.png\?vsn=d" assert digested_css =~ ~r"\.\./images/relative-#{@hash_regex}\.png\?vsn=d" refute digested_css =~ ~r"http://www.phoenixframework.org/absolute-#{@hash_regex}.png" assert digested_css =~ ~r"http://www.phoenixframework.org/absolute.png" end test "digests only absolute and relative asset paths found within stylesheets without vsn" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, false) digested_css_filename = assets_files(@output_path) |> Enum.find(&(&1 =~ ~r"app-#{@hash_regex}.css")) digested_css = Path.join(@output_path, digested_css_filename) |> File.read!() refute digested_css =~ ~r"/phoenix\.png" refute digested_css =~ ~r"\.\./images/relative\.png" assert digested_css =~ ~r"/phoenix-#{@hash_regex}\.png" assert digested_css =~ ~r"\.\./images/relative-#{@hash_regex}\.png" refute digested_css =~ ~r"http://www.phoenixframework.org/absolute-#{@hash_regex}.png" assert digested_css =~ ~r"http://www.phoenixframework.org/absolute.png" end test "sha512 matches content of digested file" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) digested_css_filename = assets_files(@output_path) |> Enum.find(&(&1 =~ ~r"app-#{@hash_regex}.css")) digested_css = Path.join(@output_path, digested_css_filename) |> File.read!() cache_manifest_file = @output_path |> assets_files() |> Enum.find(&(&1 =~ ~r"cache_manifest.json")) json = Path.join(@output_path, cache_manifest_file) |> json_read!() integrity = Base.encode64(:crypto.hash(:sha512, digested_css)) assert json["digests"][digested_css_filename]["sha512"] == integrity end test "digests sourceMappingURL asset paths found within javascript source files" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) digested_js_map_filename = assets_files(@output_path) |> Enum.find(&(&1 =~ ~r"app-#{@hash_regex}.js.map")) digested_js_filename = assets_files(@output_path) |> Enum.find(&(&1 =~ ~r"app-#{@hash_regex}.js")) digested_js = Path.join(@output_path, digested_js_filename) |> File.read!() refute digested_js =~ "app.js.map" assert digested_js =~ "#{digested_js_map_filename}" js = Path.join(@output_path, "app.js") |> File.read!() assert js =~ "app.js.map" refute js =~ "#{digested_js_map_filename}" end test "digests file url paths found within javascript mapping files" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) digested_js_map_filename = assets_files(@output_path) |> Enum.find(&(&1 =~ ~r"app-#{@hash_regex}.js.map")) digested_js_filename = assets_files(@output_path) |> Enum.find(&(&1 =~ ~r"app-#{@hash_regex}.js")) digested_js_map = Path.join(@output_path, digested_js_map_filename) |> File.read!() refute digested_js_map =~ ~r"\"file\":\"app.js\"" assert digested_js_map =~ ~r"#{digested_js_filename}" end test "does not digest assets within undigested files" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) undigested_css = Path.join(@output_path, "css/app.css") |> File.read!() assert undigested_css =~ ~r"/phoenix\.png" assert undigested_css =~ ~r"\.\./images/relative\.png" refute undigested_css =~ ~r"/phoenix-#{@hash_regex}\.png" refute undigested_css =~ ~r"\.\./images/relative-#{@hash_regex}\.png" end test "digested sourcemaps and their asset share the same hash" do input_path = "test/fixtures/digest/priv/static/" assert :ok = Phoenix.Digester.compile(input_path, @output_path, true) json = Path.join(@output_path, "cache_manifest.json") |> json_read!() assert json["latest"]["app.js.map"] == json["latest"]["app.js"] <> ".map" end end describe "clean" do test "fails when the given path is invalid" do assert {:error, :invalid_path} = Phoenix.Digester.clean("nonexistent path", 3600, 2) end test "removes versions over the keep count" do manifest_path = "test/fixtures/digest/cleaner/cache_manifest.json" File.mkdir_p!(@output_path) File.cp(manifest_path, "#{@output_path}/cache_manifest.json") File.touch("#{@output_path}/app.css") File.touch("#{@output_path}/app-1.css") File.touch("#{@output_path}/app-1.css.gz") File.touch("#{@output_path}/app-2.css") File.touch("#{@output_path}/app-2.css.gz") File.touch("#{@output_path}/app-3.css") File.touch("#{@output_path}/app-3.css.gz") File.touch("#{@output_path}/manifest.json") File.touch("#{@output_path}/manifest.json.gz") File.touch("#{@output_path}/app.css") assert :ok = Phoenix.Digester.clean(@output_path, 3600, 1, @fake_now) output_files = assets_files(@output_path) assert "app.css" in output_files assert "app-3.css" in output_files assert "app-3.css.gz" in output_files assert "app-2.css" in output_files assert "app-2.css.gz" in output_files assert "manifest.json" in output_files assert "manifest.json.gz" in output_files refute "app-1.css" in output_files refute "app-1.css.gz" in output_files end test "removes files older than specified number of seconds" do manifest_path = "test/fixtures/digest/cleaner/cache_manifest.json" File.mkdir_p!(@output_path) File.cp(manifest_path, "#{@output_path}/cache_manifest.json") File.touch("#{@output_path}/app.css") File.touch("#{@output_path}/app-1.css") File.touch("#{@output_path}/app-1.css.gz") File.touch("#{@output_path}/app-2.css") File.touch("#{@output_path}/app-2.css.gz") File.touch("#{@output_path}/app-3.css") File.touch("#{@output_path}/app-3.css.gz") File.touch("#{@output_path}/manifest.json") File.touch("#{@output_path}/manifest.json.gz") File.touch("#{@output_path}/app.css") assert :ok = Phoenix.Digester.clean(@output_path, 1, 10, @fake_now) output_files = assets_files(@output_path) assert "app.css" in output_files assert "app-2.css" in output_files assert "app-2.css.gz" in output_files assert "app-3.css" in output_files assert "app-3.css.gz" in output_files assert "manifest.json" in output_files assert "manifest.json.gz" in output_files refute "app-1.css" in output_files refute "app-1.css.gz" in output_files end test "cleaning doesn't delete the latest even if the mtime is wrong" do manifest_path = "test/fixtures/digest/cleaner/latest_not_most_recent_cache_manifest.json" File.mkdir_p!(@output_path) File.cp(manifest_path, "#{@output_path}/cache_manifest.json") File.touch("#{@output_path}/app.css") File.touch("#{@output_path}/app-1.css") File.touch("#{@output_path}/app-1.css.gz") File.touch("#{@output_path}/app-2.css") File.touch("#{@output_path}/app-2.css.gz") File.touch("#{@output_path}/app-3.css") File.touch("#{@output_path}/app-3.css.gz") File.touch("#{@output_path}/manifest.json") File.touch("#{@output_path}/manifest.json.gz") File.touch("#{@output_path}/app.css") assert :ok = Phoenix.Digester.clean(@output_path, 3600, 1, @fake_now) output_files = assets_files(@output_path) assert "app.css" in output_files assert "app-3.css" in output_files assert "app-3.css.gz" in output_files assert "app-2.css" in output_files assert "app-2.css.gz" in output_files assert "manifest.json" in output_files assert "manifest.json.gz" in output_files refute "app-1.css" in output_files refute "app-1.css.gz" in output_files end test "cleaning updates cache manifest to remove cleaned files" do manifest_path = "test/fixtures/digest/cleaner/cache_manifest.json" File.mkdir_p!(@output_path) File.cp(manifest_path, "#{@output_path}/cache_manifest.json") File.touch("#{@output_path}/app.css") File.touch("#{@output_path}/app-1.css") File.touch("#{@output_path}/app-1.css.gz") File.touch("#{@output_path}/app-2.css") File.touch("#{@output_path}/app-2.css.gz") File.touch("#{@output_path}/app-3.css") File.touch("#{@output_path}/app-3.css.gz") File.touch("#{@output_path}/manifest.json") File.touch("#{@output_path}/manifest.json.gz") File.touch("#{@output_path}/app.css") assert :ok = Phoenix.Digester.clean(@output_path, 3600, 1, @fake_now) json = Path.join(@output_path, "cache_manifest.json") |> json_read!() refute json["digests"]["app-1.css"] end test "removes compressed versions from all static compressors" do add_digest_test_compressor() manifest_path = "test/fixtures/digest/cleaner/cache_manifest.json" File.mkdir_p!(@output_path) File.cp(manifest_path, "#{@output_path}/cache_manifest.json") File.touch("#{@output_path}/app.css") File.touch("#{@output_path}/app-1.css") File.touch("#{@output_path}/app-1.css.gz") File.touch("#{@output_path}/app-1.css.digest_test") File.touch("#{@output_path}/manifest.json") File.touch("#{@output_path}/manifest.json.gz") File.touch("#{@output_path}/manifest.json.digest_test") assert :ok = Phoenix.Digester.clean(@output_path, 1, 10, @fake_now) output_files = assets_files(@output_path) assert "app.css" in output_files assert "manifest.json" in output_files assert "manifest.json.gz" in output_files assert "manifest.json.digest_test" in output_files refute "app-1.css" in output_files refute "app-1.css.gz" in output_files refute "app-1.css.digest_test" in output_files end end describe "clean_all" do test "fails when the given path is invalid" do assert {:error, :invalid_path} = Phoenix.Digester.clean_all("nonexistent path") end test "no-op when the given path does not contain cache_manifest.json" do output_path = "test/fixtures/digest/priv/static/css" assert assets_files(output_path) == ["app.css"] assert :ok = Phoenix.Digester.clean_all(output_path) assert assets_files(output_path) == ["app.css"] end test "removes all compressed/compiled files including latest and manifest" do manifest_path = "test/fixtures/digest/cleaner/cache_manifest.json" File.mkdir_p!(@output_path) File.cp(manifest_path, "#{@output_path}/cache_manifest.json") File.touch("#{@output_path}/app.css") File.touch("#{@output_path}/app.css.gz") File.touch("#{@output_path}/app-1.css") File.touch("#{@output_path}/app-1.css.gz") File.touch("#{@output_path}/app-2.css") File.touch("#{@output_path}/app-2.css.gz") File.touch("#{@output_path}/app-3.css") File.touch("#{@output_path}/app-3.css.gz") File.touch("#{@output_path}/manifest.json") File.touch("#{@output_path}/manifest.json.gz") File.touch("#{@output_path}/app.css") assert :ok = Phoenix.Digester.clean_all(@output_path) output_files = assets_files(@output_path) assert "app.css" in output_files refute "app.css.gz" in output_files refute "app-3.css" in output_files refute "app-3.css.gz" in output_files refute "app-2.css" in output_files refute "app-2.css.gz" in output_files refute "app-1.css" in output_files refute "app-1.css.gz" in output_files assert "manifest.json" in output_files assert "manifest.json.gz" in output_files refute "cache_manifest.json" in output_files end test "removes compressed versions from all static compressors" do add_digest_test_compressor() manifest_path = "test/fixtures/digest/cleaner/cache_manifest.json" File.mkdir_p!(@output_path) File.cp(manifest_path, "#{@output_path}/cache_manifest.json") File.touch("#{@output_path}/app.css") File.touch("#{@output_path}/app.css.gz") File.touch("#{@output_path}/app.css.digest_test") File.touch("#{@output_path}/manifest.json") File.touch("#{@output_path}/manifest.json.gz") File.touch("#{@output_path}/manifest.json.digest_test") assert :ok = Phoenix.Digester.clean_all(@output_path) output_files = assets_files(@output_path) assert "app.css" in output_files refute "app.css.gz" in output_files refute "app.css.digest_test" in output_files assert "manifest.json" in output_files assert "manifest.json.gz" in output_files assert "manifest.json.digest_test" in output_files refute "cache_manifest.json" in output_files end end defp assets_files(path) do path |> Path.join("**/*") |> Path.wildcard() |> Enum.filter(&(!File.dir?(&1))) |> Enum.map(&Path.relative_to(&1, path)) end defp now do :calendar.datetime_to_gregorian_seconds(:calendar.universal_time()) end defp json_read!(path) do path |> File.read!() |> Phoenix.json_library().decode!() end defp add_digest_test_compressor() do compressors = Application.fetch_env!(:phoenix, :static_compressors) Application.put_env(:phoenix, :static_compressors, [DigestTestCompressor | compressors]) on_exit(fn -> Application.put_env(:phoenix, :static_compressors, compressors) end) end end ================================================ FILE: test/phoenix/endpoint/endpoint_test.exs ================================================ System.put_env("ENDPOINT_TEST_HOST", "example.com") System.put_env("ENDPOINT_TEST_PORT", "80") System.put_env("ENDPOINT_TEST_ASSET_HOST", "assets.example.com") System.put_env("ENDPOINT_TEST_ASSET_PORT", "443") defmodule Phoenix.Endpoint.EndpointTest do use ExUnit.Case, async: true use RouterHelper @config [ url: [host: {:system, "ENDPOINT_TEST_HOST"}, path: "/api"], static_url: [host: "static.example.com"], server: false, http: [port: 80], https: [port: 443], force_ssl: [subdomains: true], cache_manifest_skip_vsn: false, cache_static_manifest: "../../../../test/fixtures/digest/compile/cache_manifest.json", pubsub_server: :endpoint_pub ] Application.put_env(:phoenix, __MODULE__.Endpoint, @config) defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix # Assert endpoint variables assert @otp_app == :phoenix assert code_reloading? == false assert debug_errors? == false end defmodule NoConfigEndpoint do use Phoenix.Endpoint, otp_app: :phoenix end defmodule SystemTupleEndpoint do use Phoenix.Endpoint, otp_app: :phoenix end defmodule TelemetryEventEndpoint do use Phoenix.Endpoint, otp_app: :phoenix end setup_all do ExUnit.CaptureLog.capture_log(fn -> start_supervised!(Endpoint) end) start_supervised!({Phoenix.PubSub, name: :endpoint_pub}) on_exit(fn -> Application.delete_env(:phoenix, :serve_endpoints) end) :ok end test "defines child_spec/1" do assert Endpoint.child_spec([]) == %{ id: Endpoint, start: {Endpoint, :start_link, [[]]}, type: :supervisor } end test "warns if there is no configuration for an endpoint" do assert ExUnit.CaptureLog.capture_log(fn -> NoConfigEndpoint.start_link() end) =~ "no configuration" end test "has reloadable configuration" do endpoint_id = Endpoint.config(:endpoint_id) assert Endpoint.config(:url) == [host: {:system, "ENDPOINT_TEST_HOST"}, path: "/api"] assert Endpoint.config(:static_url) == [host: "static.example.com"] assert Endpoint.url() == "https://example.com" assert Endpoint.path("/") == "/api/" assert Endpoint.static_url() == "https://static.example.com" assert Endpoint.struct_url() == %URI{scheme: "https", host: "example.com", port: 443} config = @config |> put_in([:url, :port], 1234) |> put_in([:static_url, :port], 456) assert Endpoint.config_change([{Endpoint, config}], []) == :ok assert Endpoint.config(:endpoint_id) == endpoint_id assert Enum.sort(Endpoint.config(:url)) == [host: {:system, "ENDPOINT_TEST_HOST"}, path: "/api", port: 1234] assert Enum.sort(Endpoint.config(:static_url)) == [host: "static.example.com", port: 456] assert Endpoint.url() == "https://example.com:1234" assert Endpoint.path("/") == "/api/" assert Endpoint.static_url() == "https://static.example.com:456" assert Endpoint.struct_url() == %URI{scheme: "https", host: "example.com", port: 1234} end test "{:system, env_var} tuples are deprecated" do Application.put_env(:phoenix, __MODULE__.SystemTupleEndpoint, url: [ host: {:system, "ENDPOINT_TEST_HOST"}, port: {:system, "ENDPOINT_TEST_PORT"} ], static_url: [ host: {:system, "ENDPOINT_TEST_ASSET_HOST"}, port: {:system, "ENDPOINT_TEST_ASSET_PORT"} ] ) log = ExUnit.CaptureLog.capture_log(fn -> start_supervised!(SystemTupleEndpoint) end) assert log =~ ~S|host: System.get_env("ENDPOINT_TEST_HOST")| assert log =~ ~S|port: System.get_env("ENDPOINT_TEST_PORT")| assert log =~ ~S|host: System.get_env("ENDPOINT_TEST_ASSET_HOST")| assert log =~ ~S|port: System.get_env("ENDPOINT_TEST_ASSET_PORT")| end test "start_link/2 should emit an Endpoint init event" do # Set up the test telemetry event :telemetry.attach( [:test, :endpoint, :init, :handler], [:phoenix, :endpoint, :init], &__MODULE__.validate_init_event/4, nil ) Application.put_env(:phoenix, __MODULE__.TelemetryEventEndpoint, server: false) start_supervised!(TelemetryEventEndpoint) after :telemetry.detach([:test, :endpoint, :init, :handler]) end def validate_init_event(event, measurements, metadata, _config) do assert event == [:phoenix, :endpoint, :init] assert Process.whereis(TelemetryEventEndpoint) == metadata.pid assert metadata.module == TelemetryEventEndpoint assert metadata.otp_app == :phoenix assert metadata.config == [server: false] assert Map.has_key?(measurements, :system_time) end test "sets script name when using path" do conn = conn(:get, "https://example.com/") assert Endpoint.call(conn, []).script_name == ~w"api" conn = put_in(conn.script_name, ~w(foo)) assert Endpoint.call(conn, []).script_name == ~w"api" end @tag :capture_log test "redirects http requests to https on force_ssl" do conn = Endpoint.call(conn(:get, "/"), []) assert get_resp_header(conn, "location") == ["https://example.com/"] assert conn.halted end test "sends hsts on https requests on force_ssl" do conn = Endpoint.call(conn(:get, "https://example.com/"), []) assert get_resp_header(conn, "strict-transport-security") == ["max-age=31536000; includeSubDomains"] end test "warms up caches on load and config change" do assert Endpoint.config_change([{Endpoint, @config}], []) == :ok assert Endpoint.config(:cache_static_manifest_latest) == %{"foo.css" => "foo-d978852bea6530fcd197b5445ed008fd.css"} assert Endpoint.static_path("/foo.css") == "/foo-d978852bea6530fcd197b5445ed008fd.css?vsn=d" # Trigger a config change and the cache should be warmed up again config = put_in( @config[:cache_static_manifest], "../../../../test/fixtures/digest/compile/cache_manifest_upgrade.json" ) assert Endpoint.config_change([{Endpoint, config}], []) == :ok assert Endpoint.config(:cache_static_manifest_latest) == %{"foo.css" => "foo-ghijkl.css"} assert Endpoint.static_path("/foo.css") == "/foo-ghijkl.css?vsn=d" end test "uses correct path accordingly to vsn setting" do config = put_in(@config[:cache_manifest_skip_vsn], false) assert Endpoint.config_change([{Endpoint, config}], []) == :ok assert Endpoint.static_path("/foo.css") == "/foo-d978852bea6530fcd197b5445ed008fd.css?vsn=d" config = put_in(@config[:cache_manifest_skip_vsn], true) assert Endpoint.config_change([{Endpoint, config}], []) == :ok assert Endpoint.static_path("/foo.css") == "/foo-d978852bea6530fcd197b5445ed008fd.css" end test "uses correct path for resources with fragment identifier" do config = put_in(@config[:cache_manifest_skip_vsn], false) assert Endpoint.config_change([{Endpoint, config}], []) == :ok assert Endpoint.static_path("/foo.css#info") == "/foo-d978852bea6530fcd197b5445ed008fd.css?vsn=d#info" # assert that even multiple presences of a number sign are treated as a fragment assert Endpoint.static_path("/foo.css#info#me") == "/foo-d978852bea6530fcd197b5445ed008fd.css?vsn=d#info#me" end @tag :capture_log test "uses url configuration for static path" do Application.put_env(:phoenix, __MODULE__.UrlEndpoint, url: [path: "/api"]) defmodule UrlEndpoint do use Phoenix.Endpoint, otp_app: :phoenix end UrlEndpoint.start_link() assert UrlEndpoint.path("/phoenix.png") =~ "/api/phoenix.png" assert UrlEndpoint.static_path("/phoenix.png") =~ "/api/phoenix.png" after :code.purge(__MODULE__.UrlEndpoint) :code.delete(__MODULE__.UrlEndpoint) end @tag :capture_log test "uses static_url configuration for static path" do Application.put_env(:phoenix, __MODULE__.StaticEndpoint, static_url: [path: "/static"]) defmodule StaticEndpoint do use Phoenix.Endpoint, otp_app: :phoenix end StaticEndpoint.start_link() assert StaticEndpoint.path("/phoenix.png") =~ "/phoenix.png" assert StaticEndpoint.static_path("/phoenix.png") =~ "/static/phoenix.png" after :code.purge(__MODULE__.StaticEndpoint) :code.delete(__MODULE__.StaticEndpoint) end @tag :capture_log test "can find the running address and port for an endpoint" do Application.put_env(:phoenix, __MODULE__.AddressEndpoint, http: [ip: {127, 0, 0, 1}, port: 0], server: true ) defmodule AddressEndpoint do use Phoenix.Endpoint, otp_app: :phoenix end AddressEndpoint.start_link() assert {:ok, {{127, 0, 0, 1}, port}} = AddressEndpoint.server_info(:http) assert is_integer(port) after :code.purge(__MODULE__.AddressEndpoint) :code.delete(__MODULE__.AddressEndpoint) end test "injects pubsub broadcast with configured server" do Endpoint.subscribe("sometopic") some = spawn(fn -> :ok end) Endpoint.broadcast_from(some, "sometopic", "event1", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event1", payload: %{key: :val}, topic: "sometopic" } Endpoint.broadcast_from!(some, "sometopic", "event2", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event2", payload: %{key: :val}, topic: "sometopic" } Endpoint.broadcast("sometopic", "event3", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event3", payload: %{key: :val}, topic: "sometopic" } Endpoint.broadcast!("sometopic", "event4", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event4", payload: %{key: :val}, topic: "sometopic" } Endpoint.local_broadcast_from(some, "sometopic", "event1", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event1", payload: %{key: :val}, topic: "sometopic" } Endpoint.local_broadcast("sometopic", "event3", %{key: :val}) assert_receive %Phoenix.Socket.Broadcast{ event: "event3", payload: %{key: :val}, topic: "sometopic" } end test "loads cache manifest from specified application" do config = put_in( @config[:cache_static_manifest], {:phoenix, "../../../../test/fixtures/digest/compile/cache_manifest.json"} ) assert Endpoint.config_change([{Endpoint, config}], []) == :ok assert Endpoint.static_path("/foo.css") == "/foo-d978852bea6530fcd197b5445ed008fd.css?vsn=d" end test "server?/2 returns true for explicitly true server", config do endpoint = Module.concat(__MODULE__, config.test) Application.put_env(:phoenix, endpoint, server: true) assert Phoenix.Endpoint.server?(:phoenix, endpoint) end test "server?/2 returns false for explicitly false server", config do Application.put_env(:phoenix, :serve_endpoints, true) endpoint = Module.concat(__MODULE__, config.test) Application.put_env(:phoenix, endpoint, server: false) refute Phoenix.Endpoint.server?(:phoenix, endpoint) end test "server?/2 returns true for global serve_endpoints as true", config do Application.put_env(:phoenix, :serve_endpoints, true) endpoint = Module.concat(__MODULE__, config.test) Application.put_env(:phoenix, endpoint, []) assert Phoenix.Endpoint.server?(:phoenix, endpoint) end test "server?/2 returns false for no global serve_endpoints config", config do Application.delete_env(:phoenix, :serve_endpoints) endpoint = Module.concat(__MODULE__, config.test) Application.put_env(:phoenix, endpoint, []) refute Phoenix.Endpoint.server?(:phoenix, endpoint) end test "static_path/1 validates paths are local/safe" do safe_path = "/some_safe_path" assert Endpoint.static_path(safe_path) == safe_path assert_raise ArgumentError, ~r/unsafe characters/, fn -> Endpoint.static_path("/\\unsafe_path") end assert_raise ArgumentError, ~r/expected a path starting with a single/, fn -> Endpoint.static_path("//invalid_path") end end test "static_integrity/1 validates paths are local/safe" do safe_path = "/some_safe_path" assert is_nil(Endpoint.static_integrity(safe_path)) assert_raise ArgumentError, ~r/unsafe characters/, fn -> Endpoint.static_integrity("/\\unsafe_path") end assert_raise ArgumentError, ~r/expected a path starting with a single/, fn -> Endpoint.static_integrity("//invalid_path") end end test "validates websocket and longpoll socket options" do assert_raise ArgumentError, ~r/unknown keys \[:invalid\]/, fn -> defmodule MyInvalidSocketEndpoint1 do use Phoenix.Endpoint, otp_app: :phoenix socket "/ws", UserSocket, websocket: [path: "/ws", check_origin: false, invalid: true] end end assert_raise ArgumentError, ~r/unknown keys \[:drainer\]/, fn -> defmodule MyInvalidSocketEndpoint2 do use Phoenix.Endpoint, otp_app: :phoenix socket "/ws", UserSocket, longpoll: [path: "/ws", check_origin: false, drainer: []] end end end end ================================================ FILE: test/phoenix/endpoint/render_errors_test.exs ================================================ defmodule Phoenix.Endpoint.RenderErrorsTest do use ExUnit.Case, async: true use RouterHelper Application.put_env(:phoenix, __MODULE__.Endpoint, []) import ExUnit.CaptureLog view = __MODULE__ def render("app.html", assigns) do "Layout: " <> assigns.inner_content end def render("404.html", %{ kind: kind, reason: _reason, stack: _stack, status: 404, conn: conn, __changed__: nil }) do "Got 404 from #{kind} with #{conn.method}" end def render("404.json", %{ kind: kind, reason: _reason, stack: _stack, status: 404, conn: conn, __changed__: nil }) do %{error: "Got 404 from #{kind} with #{conn.method}"} end def render("415.html", %{ kind: kind, reason: _reason, stack: _stack, status: 415, conn: conn, __changed__: nil }) do "Got 415 from #{kind} with #{conn.method}" end def render("500.html", %{ kind: kind, reason: _reason, stack: _stack, status: 500, conn: conn, __changed__: nil }) do "Got 500 from #{kind} with #{conn.method}" end def render("500.text", _) do "500 in TEXT" end defmodule Router do use Plug.Router use Phoenix.Endpoint.RenderErrors, view: view, accepts: ~w(html json) plug :match plug :dispatch get "/boom" do resp(conn, 200, "oops") raise "oops" end get "/send_and_boom" do send_resp(conn, 200, "oops") raise "oops" end get "/send_and_wrapped" do stack = try do raise "oops" rescue _ -> __STACKTRACE__ end # Those are always ignored and must be explicitly opted-in. conn = conn |> Phoenix.Controller.put_layout({Unknown, "layout"}) |> Phoenix.Controller.put_root_layout({Unknown, "root"}) reason = ArgumentError.exception("oops") raise Plug.Conn.WrapperError, conn: conn, kind: :error, stack: stack, reason: reason end match _ do raise Phoenix.Router.NoRouteError, conn: conn, router: __MODULE__ end end defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix end setup do Logger.put_process_level(self(), :none) :ok end test "call/2 is overridden" do assert_raise RuntimeError, "oops", fn -> call(Router, :get, "/boom") end assert_received {:plug_conn, :sent} end test "call/2 is overridden but is a no-op when response is already sent" do assert_raise RuntimeError, "oops", fn -> call(Router, :get, "/send_and_boom") end assert_received {:plug_conn, :sent} end test "call/2 is overridden with no route match as HTML and does not reraise" do call(Router, :get, "/unknown") assert_received {:plug_conn, :sent} end test "call/2 is overridden with no route match as JSON and does not reraise" do call(Router, :get, "/unknown?_format=json") assert_received {:plug_conn, :sent} end @tag :capture_log test "call/2 is overridden with no route match while malformed format and does not reraise" do call(Router, :get, "/unknown?_format=unknown") assert_received {:plug_conn, :sent} end test "call/2 is overridden and unwraps wrapped errors" do assert_raise ArgumentError, "oops", fn -> conn(:get, "/send_and_wrapped") |> Router.call([]) end assert_received {:plug_conn, :sent} end test "logs converted errors if response has not yet been sent" do Logger.delete_process_level(self()) conn = put_endpoint(conn(:get, "/")) assert capture_log(fn -> assert_render(500, conn, [], fn -> throw(:hello) end) end) =~ "Converted throw :hello to 500" assert capture_log(fn -> assert_render(500, conn, [], fn -> raise "boom" end) end) =~ "Converted error RuntimeError to 500" assert capture_log(fn -> assert_render(500, conn, [], fn -> exit(:timeout) end) end) =~ "Converted exit :timeout to 500" end test "does not log converted errors if response already sent" do conn = put_endpoint(conn(:get, "/")) try do try do Plug.Conn.send_resp(conn, 200, "hello") throw(:hello) catch kind, reason -> stack = __STACKTRACE__ opts = [view: __MODULE__, accepts: ~w(html)] Phoenix.Endpoint.RenderErrors.__catch__(conn, kind, reason, stack, opts) else _ -> flunk("function should have failed") end catch :throw, :hello -> :ok end end defp put_endpoint(conn) do Plug.Conn.put_private(conn, :phoenix_endpoint, Endpoint) end defp assert_render(status, conn, opts, func) do opts = if opts[:formats] do opts else opts |> Keyword.put_new(:view, __MODULE__) |> Keyword.put_new(:accepts, ~w(html)) end {^status, _, body} = Phoenix.ConnTest.assert_error_sent(status, fn -> try do func.() catch kind, reason -> stack = __STACKTRACE__ Phoenix.Endpoint.RenderErrors.__catch__(conn, kind, reason, stack, opts) else _ -> flunk("function should have failed") end end) body end test "exception page for throws" do body = assert_render(500, conn(:get, "/"), [], fn -> throw(:hello) end) assert body == "Got 500 from throw with GET" end test "exception page for errors" do body = assert_render(500, conn(:get, "/"), [], fn -> :erlang.error(:badarg) end) assert body == "Got 500 from error with GET" end test "exception page for exceptions" do body = assert_render(415, conn(:get, "/"), [], fn -> raise Plug.Parsers.UnsupportedMediaTypeError, media_type: "foo/bar" end) assert body == "Got 415 from error with GET" end test "exception page for exits" do body = assert_render(500, conn(:get, "/"), [], fn -> exit({:timedout, {GenServer, :call, [:foo, :bar]}}) end) assert body == "Got 500 from exit with GET" end test "exception page ignores params _format" do conn = conn(:get, "/", _format: "text") body = assert_render(500, conn, [accepts: ["html", "text"]], fn -> throw(:hello) end) assert body == "500 in TEXT" end test "exception page uses stored _format" do conn = conn(:get, "/") |> put_private(:phoenix_format, "text") body = assert_render(500, conn, [accepts: ["html", "text"]], fn -> throw(:hello) end) assert body == "500 in TEXT" end test "exception page with custom format" do body = assert_render(500, conn(:get, "/"), [accepts: ~w(text)], fn -> throw(:hello) end) assert body == "500 in TEXT" end test "exception page with layout" do body = assert_render(500, conn(:get, "/"), [layout: {__MODULE__, :app}], fn -> throw(:hello) end) assert body == "Layout: Got 500 from throw with GET" end test "exception page with root layout" do body = assert_render(500, conn(:get, "/"), [root_layout: {__MODULE__, :app}], fn -> throw(:hello) end) assert body == "Layout: Got 500 from throw with GET" end test "exception page with formats" do body = assert_render(500, conn(:get, "/"), [formats: [text: __MODULE__]], fn -> throw(:hello) end) assert body == "500 in TEXT" end test "exception page is shown even with invalid format" do conn = conn(:get, "/") |> put_req_header("accept", "unknown/unknown") body = assert_render(500, conn, [], fn -> throw(:hello) end) assert body == "Got 500 from throw with GET" end test "exception page is shown even with invalid query parameters" do body = assert_render(500, conn(:get, "/?q=%{"), [], fn -> throw(:hello) end) assert body == "Got 500 from throw with GET" end test "captures warning when format is not supported" do Logger.delete_process_level(self()) assert capture_log(fn -> conn = conn(:get, "/") |> put_req_header("accept", "unknown/unknown") assert_render(500, conn, [], fn -> throw(:hello) end) end) =~ "Could not render errors due to no supported media type in accept header" end test "captures warning when format does not match error view" do Logger.delete_process_level(self()) assert capture_log(fn -> conn = conn(:get, "/?_format=unknown") assert_render(500, conn, [], fn -> throw(:hello) end) end) =~ "Could not render errors due to unknown format \"unknown\"" end test "exception page for NoRouteError with plug_status 404 renders and does not reraise" do conn = call(Router, :get, "/unknown") assert Phoenix.ConnTest.response(conn, 404) =~ "Got 404 from error with GET" end end ================================================ FILE: test/phoenix/endpoint/supervisor_test.exs ================================================ defmodule Phoenix.Endpoint.SupervisorTest do use ExUnit.Case, async: false alias Phoenix.Endpoint.Supervisor defmodule HTTPSEndpoint do def config(:otp_app), do: :phoenix def config(:https), do: [port: 443] def config(:http), do: false def config(:url), do: [host: "example.com"] def config(_), do: nil end defmodule HTTPEndpoint do def config(:otp_app), do: :phoenix def config(:https), do: false def config(:http), do: [port: 80] def config(:url), do: [host: "example.com"] def config(_), do: nil end defmodule HTTPEnvVarEndpoint do def config(:otp_app), do: :phoenix def config(:https), do: false def config(:http), do: [port: {:system, "PHOENIX_PORT"}] def config(:url), do: [host: {:system, "PHOENIX_HOST"}] def config(_), do: nil end defmodule URLEndpoint do def config(:https), do: false def config(:http), do: false def config(:url), do: [host: "example.com", port: 678, scheme: "random"] def config(_), do: nil end defmodule StaticURLEndpoint do def config(:https), do: false def config(:http), do: [] def config(:url), do: [] def config(:static_url), do: [host: "static.example.com"] def config(_), do: nil end defmodule ServerEndpoint do def __sockets__(), do: [] end setup_all do Application.put_env(:phoenix, SupervisorApp.Endpoint, custom: true) System.put_env("PHOENIX_PORT", "8080") System.put_env("PHOENIX_HOST", "example.org") [HTTPSEndpoint, HTTPEndpoint, HTTPEnvVarEndpoint, URLEndpoint, StaticURLEndpoint] |> Enum.each(&Supervisor.warmup/1) :ok end defp persistent!(endpoint), do: :persistent_term.get({Phoenix.Endpoint, endpoint}) test "generates the static url based on the static host configuration" do assert persistent!(StaticURLEndpoint).static_url == "http://static.example.com" end test "static url fallbacks to url when there is no configuration for static_url" do assert persistent!(URLEndpoint).static_url == "random://example.com:678" end test "generates url" do assert persistent!(URLEndpoint).url == "random://example.com:678" assert persistent!(HTTPEndpoint).url == "http://example.com" assert persistent!(HTTPSEndpoint).url == "https://example.com" assert persistent!(HTTPEnvVarEndpoint).url == "http://example.org:8080" end test "static_path/2 returns file's path with lookup cache" do assert {:nocache, {"/phoenix.png", nil}} = Supervisor.static_lookup(HTTPEndpoint, "/phoenix.png") assert {:nocache, {"/images/unknown.png", nil}} = Supervisor.static_lookup(HTTPEndpoint, "/images/unknown.png") end import ExUnit.CaptureLog test "logs info if :http or :https configuration is set but not :server when running in release" do # simulate running inside release System.put_env("RELEASE_NAME", "phoenix-test") Application.put_env(:phoenix, ServerEndpoint, server: false, http: [], https: []) assert capture_log(fn -> {:ok, {_, _children}} = Supervisor.init({:phoenix, ServerEndpoint, []}) end) =~ "Configuration :server" Application.put_env(:phoenix, ServerEndpoint, server: false, http: []) assert capture_log(fn -> {:ok, {_, _children}} = Supervisor.init({:phoenix, ServerEndpoint, []}) end) =~ "Configuration :server" Application.put_env(:phoenix, ServerEndpoint, server: false, https: []) assert capture_log(fn -> {:ok, {_, _children}} = Supervisor.init({:phoenix, ServerEndpoint, []}) end) =~ "Configuration :server" Application.put_env(:phoenix, ServerEndpoint, server: false) refute capture_log(fn -> {:ok, {_, _children}} = Supervisor.init({:phoenix, ServerEndpoint, []}) end) =~ "Configuration :server" Application.put_env(:phoenix, ServerEndpoint, server: true) refute capture_log(fn -> {:ok, {_, _children}} = Supervisor.init({:phoenix, ServerEndpoint, []}) end) =~ "Configuration :server" Application.delete_env(:phoenix, ServerEndpoint) end describe "watchers" do defmodule WatchersEndpoint do def __sockets__(), do: [] end @watchers [esbuild: {Esbuild, :install_and_run, [:default, ~w(--sourcemap=inline --watch)]}] test "init/1 starts watcher children when `:server` config is true" do Application.put_env(:phoenix, WatchersEndpoint, server: true, watchers: @watchers) {:ok, {_, children}} = Supervisor.init({:phoenix, WatchersEndpoint, []}) assert Enum.any?(children, fn %{start: {Phoenix.Endpoint.Watcher, :start_link, _config}} -> true _ -> false end) end test "init/1 doesn't start watchers when `:server` config is true and `:watchers` is false" do Application.put_env(:phoenix, WatchersEndpoint, server: true, watchers: false) {:ok, {_, children}} = Supervisor.init({:phoenix, WatchersEndpoint, []}) refute Enum.any?(children, fn %{start: {Phoenix.Endpoint.Watcher, :start_link, _config}} -> true _ -> false end) end test "init/1 doesn't start watchers when `:server` config is false" do Application.put_env(:phoenix, WatchersEndpoint, server: false, watchers: @watchers) {:ok, {_, children}} = Supervisor.init({:phoenix, WatchersEndpoint, []}) refute Enum.any?(children, fn %{start: {Phoenix.Endpoint.Watcher, :start_link, _config}} -> true _ -> false end) end test "init/1 starts watcher children when `:server` config is false and `:force_watchers` is true" do Application.put_env(:phoenix, WatchersEndpoint, server: false, force_watchers: true, watchers: @watchers ) {:ok, {_, children}} = Supervisor.init({:phoenix, WatchersEndpoint, []}) assert Enum.any?(children, fn %{start: {Phoenix.Endpoint.Watcher, :start_link, _config}} -> true _ -> false end) end end describe "origin & CSRF checks config" do defmodule TestSocket do @behaviour Phoenix.Socket.Transport def child_spec(_), do: :ignore def connect(_), do: {:ok, []} def init(state), do: {:ok, state} def handle_in(_, state), do: {:ok, state} def handle_info(_, state), do: {:ok, state} def terminate(_, _), do: :ok end defmodule SocketEndpoint do use Phoenix.Endpoint, otp_app: :phoenix socket "/ws", TestSocket, websocket: [check_csrf: false, check_origin: false] end Application.put_env(:phoenix, SocketEndpoint, []) test "fails when CSRF and origin checks both disabled in transport" do assert_raise ArgumentError, ~r/one of :check_origin and :check_csrf must be set/, fn -> Supervisor.init({:phoenix, SocketEndpoint, []}) end end defmodule SocketEndpointOriginCheckDisabled do use Phoenix.Endpoint, otp_app: :phoenix socket "/ws", TestSocket, websocket: [check_csrf: false] end Application.put_env(:phoenix, SocketEndpointOriginCheckDisabled, check_origin: false) test "fails when origin is disabled in endpoint config and CSRF disabled in transport" do assert_raise ArgumentError, ~r/one of :check_origin and :check_csrf must be set/, fn -> Supervisor.init({:phoenix, SocketEndpointOriginCheckDisabled, []}) end end end end ================================================ FILE: test/phoenix/endpoint/watcher_test.exs ================================================ defmodule Phoenix.Endpoint.WatcherTest do use ExUnit.Case, async: true alias Phoenix.Endpoint.Watcher import ExUnit.CaptureIO test "starts watching and writes to stdio with args" do assert capture_io(fn -> {:ok, pid} = Watcher.start_link({"echo", ["hello", cd: File.cwd!()]}) ref = Process.monitor(pid) assert_receive {:DOWN, ^ref, :process, ^pid, :normal}, 1000 end) == "hello\n" end test "starts watching and writes to stdio with fun" do assert capture_io(fn -> {:ok, pid} = Watcher.start_link({"echo", {IO, :puts, ["hello"]}}) ref = Process.monitor(pid) assert_receive {:DOWN, ^ref, :process, ^pid, :normal}, 1000 end) == "hello\n" end end ================================================ FILE: test/phoenix/integration/endpoint_test.exs ================================================ Code.require_file "../../support/http_client.exs", __DIR__ Code.require_file "../../support/endpoint_helper.exs", __DIR__ defmodule Phoenix.Integration.EndpointTest do use ExUnit.Case, async: false import ExUnit.CaptureLog import Phoenix.Integration.EndpointHelper alias Phoenix.Integration.AdapterTest.ProdEndpoint alias Phoenix.Integration.AdapterTest.DevEndpoint alias Phoenix.Integration.AdapterTest.ProdInet6Endpoint # Find available ports to use for this test [dev, prod, prod_inet6] = get_unused_port_numbers(3) @dev dev @prod prod @prod_inet6 prod_inet6 Application.put_env(:endpoint_int, ProdEndpoint, http: [port: @prod], url: [host: "example.com"], server: true, drainer: false, render_errors: [accepts: ~w(html json)]) Application.put_env(:endpoint_int, DevEndpoint, http: [port: @dev], debug_errors: true, drainer: false) Application.put_env(:endpoint_int, ProdInet6Endpoint, http: [port: @prod_inet6, transport_options: [socket_opts: [:inet6]]], url: [host: "example.com"], server: true) defmodule Router do @moduledoc """ Let's use a plug router to test this endpoint. """ use Plug.Router plug :match plug :dispatch get "/" do send_resp conn, 200, "ok" end get "/router/oops" do _ = conn raise "oops" end match _ do raise Phoenix.Router.NoRouteError, conn: conn, router: __MODULE__ end def __routes__ do [] end end defmodule Wrapper do @moduledoc """ A wrapper around the endpoint call to extract information. This exists so we can verify that the exception handling in the Phoenix endpoint is working as expected. In order to do that, we need to wrap the endpoint.call/2 in a before compile callback so it wraps the whole stack, including render errors and debug errors functionality. """ defmacro __before_compile__(_) do quote do defoverridable [call: 2] def call(conn, opts) do # Assert we never have a lingering sent message in the inbox refute_received {:plug_conn, :sent} try do super(conn, opts) after # When we pipe downstream, downstream will always render, # either because the router is responding or because the # endpoint error layer is kicking in. assert_received {:plug_conn, :sent} send self(), {:plug_conn, :sent} end end end end end for mod <- [ProdEndpoint, DevEndpoint, ProdInet6Endpoint] do defmodule mod do use Phoenix.Endpoint, otp_app: :endpoint_int @before_compile Wrapper plug :oops plug Router @doc """ Verify errors from the plug stack too (before the router). """ def oops(conn, _opts) do if conn.path_info == ~w(oops) do raise "oops" else conn end end end end alias Phoenix.Integration.HTTPClient test "starts drainer in supervision tree if configured" do capture_log fn -> {:ok, _} = ProdInet6Endpoint.start_link() assert List.keyfind(Supervisor.which_children(ProdInet6Endpoint), Plug.Cowboy.Drainer, 0) Supervisor.stop(ProdInet6Endpoint) {:ok, _} = ProdEndpoint.start_link() refute List.keyfind(Supervisor.which_children(ProdEndpoint), Plug.Cowboy.Drainer, 0) Supervisor.stop(ProdEndpoint) end end test "adapters starts on configured port and serves requests and stops for prod" do capture_log fn -> # Has server: true {:ok, _} = ProdEndpoint.start_link() # Requests {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@prod}", %{}) assert resp.status == 200 assert resp.body == "ok" {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@prod}/unknown", %{}) assert resp.status == 404 assert resp.body == "404.html from Phoenix.ErrorView" {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@prod}/unknown?_format=json", %{}) assert resp.status == 404 assert resp.body |> Phoenix.json_library().decode!() == %{"error" => "Got 404 from error with GET"} capture_log(fn -> {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@prod}/oops", %{}) assert resp.status == 500 assert resp.body == "500.html from Phoenix.ErrorView" {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@prod}/router/oops", %{}) assert resp.status == 500 assert resp.body == "500.html from Phoenix.ErrorView" Supervisor.stop(ProdEndpoint) end) {:error, _reason} = HTTPClient.request(:get, "http://127.0.0.1:#{@prod}", %{}) end end test "adapters starts on configured port and serves requests and stops for dev" do # Toggle globally serve_endpoints(true) on_exit(fn -> serve_endpoints(false) end) capture_log fn -> # Has server: false {:ok, _} = DevEndpoint.start_link() # Requests {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@dev}", %{}) assert resp.status == 200 assert resp.body == "ok" {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@dev}/unknown", %{}) assert resp.status == 404 assert resp.body =~ "NoRouteError at GET /unknown" capture_log(fn -> {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@dev}/oops", %{}) assert resp.status == 500 assert resp.body =~ "RuntimeError at GET /oops" {:ok, resp} = HTTPClient.request(:get, "http://127.0.0.1:#{@dev}/router/oops", %{}) assert resp.status == 500 assert resp.body =~ "RuntimeError at GET /router/oops" Supervisor.stop(DevEndpoint) end) {:error, _reason} = HTTPClient.request(:get, "http://127.0.0.1:#{@dev}", %{}) end end test "adapters starts on configured port and inet6 for prod" do capture_log fn -> # Has server: true {:ok, _} = ProdInet6Endpoint.start_link() Supervisor.stop(ProdInet6Endpoint) end end defp serve_endpoints(bool) do Application.put_env(:phoenix, :serve_endpoints, bool) end end ================================================ FILE: test/phoenix/integration/long_poll_channels_test.exs ================================================ Code.require_file("../../support/http_client.exs", __DIR__) defmodule Phoenix.Integration.LongPollChannelsTest do # TODO: use parameterized tests once we require Elixir 1.18 use ExUnit.Case import ExUnit.CaptureLog alias Phoenix.Integration.HTTPClient alias Phoenix.Socket.{Broadcast, Message, V1, V2} alias __MODULE__.Endpoint @moduletag :capture_log @port 5808 @pool_size 1 Application.put_env(:phoenix, Endpoint, https: false, http: [port: @port], secret_key_base: String.duplicate("abcdefgh", 8), server: true, drainer: false, pubsub_server: __MODULE__ ) defmodule RoomChannel do use Phoenix.Channel, log_join: :info, log_handle_in: :info intercept ["new_msg", "bin_ack"] def join(topic, message, socket) do Process.register(self(), String.to_atom(topic)) send(self(), {:after_join, message}) {:ok, socket} end def handle_info({:after_join, message}, socket) do broadcast(socket, "user_entered", %{user: message["user"]}) push(socket, "joined", Map.merge(%{status: "connected"}, socket.assigns)) {:noreply, socket} end def handle_in("bin", {:binary, _bin}, socket) do broadcast!(socket, "bin_ack", %{}) {:noreply, socket} end def handle_in("new_msg", message, socket) do broadcast!(socket, "new_msg", message) {:noreply, socket} end def handle_in("boom", _message, _socket) do raise "boom" end def handle_out(event, payload, socket) do push(socket, event, Map.put(payload, "transport", inspect(socket.transport))) {:noreply, socket} end end defmodule UserSocketConnectInfo do use Phoenix.Socket channel "room:*", RoomChannel def connect(params, socket, connect_info) do unless params["logging"] == "enabled", do: Logger.put_process_level(self(), :none) address = Tuple.to_list(connect_info.peer_data.address) |> Enum.join(".") trace_context_headers = Enum.into(connect_info.trace_context_headers, %{}) uri = Map.from_struct(connect_info.uri) x_headers = Enum.into(connect_info.x_headers, %{}) connect_info = connect_info |> update_in([:peer_data], &Map.put(&1, :address, address)) |> Map.put(:trace_context_headers, trace_context_headers) |> Map.put(:uri, uri) |> Map.put(:x_headers, x_headers) socket = socket |> assign(:user_id, params["user_id"]) |> assign(:connect_info, connect_info) {:ok, socket} end def id(socket) do if id = socket.assigns.user_id, do: "user_sockets:#{id}" end end defmodule UserSocket do use Phoenix.Socket channel "room:*", RoomChannel def connect(%{"reject" => "true"}, _socket) do :error end def connect(%{"custom_error" => "true"}, _socket) do {:error, :custom} end def connect(params, socket) do unless params["logging"] == "enabled", do: Logger.put_process_level(self(), :none) {:ok, assign(socket, :user_id, params["user_id"])} end def id(socket) do if id = socket.assigns.user_id, do: "user_sockets:#{id}" end end defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix socket "/ws", UserSocket, longpoll: [ window_ms: 200, pubsub_timeout_ms: 200, check_origin: ["//example.com"] ] socket "/ws/admin", UserSocket, longpoll: [ window_ms: 200, pubsub_timeout_ms: 200, check_origin: ["//example.com"] ] socket "/ws/connect_info", UserSocketConnectInfo, longpoll: [ window_ms: 200, pubsub_timeout_ms: 200, check_origin: ["//example.com"], connect_info: [:trace_context_headers, :x_headers, :peer_data, :uri] ] end setup %{adapter: adapter} do config = Application.get_env(:phoenix, Endpoint) Application.put_env(:phoenix, Endpoint, Keyword.merge(config, adapter: adapter)) capture_log(fn -> start_supervised!(Endpoint) end) start_supervised!({Phoenix.PubSub, name: __MODULE__, pool_size: @pool_size}) :ok end setup config do for {_, pid, _, _} <- DynamicSupervisor.which_children(Phoenix.Transports.LongPoll.Supervisor) do DynamicSupervisor.terminate_child(Phoenix.Transports.LongPoll.Supervisor, pid) end {:ok, topic: "room:" <> to_string(config.test)} end def assert_down(topic) do ref = Process.monitor(Process.whereis(:"#{topic}")) assert_receive {:DOWN, ^ref, :process, _pid, _} end @doc """ Helper method to maintain token session state when making HTTP requests. Returns a response with body decoded into JSON map. """ def poll(method, path, vsn, params, json \\ nil, headers \\ %{}) do {serializer, json} = serializer(vsn, json) headers = if is_list(json) do Map.merge(%{"content-type" => "application/x-ndjson"}, headers) else Map.merge(%{"content-type" => "application/json"}, headers) end body = encode(serializer, json) query_string = params |> Map.put("vsn", vsn) |> URI.encode_query() url = "http://127.0.0.1:#{@port}#{path}/longpoll?" <> query_string {:ok, resp} = HTTPClient.request(method, url, headers, body) decode_body(serializer, resp) end defp serializer("2." <> _, json), do: {V2.JSONSerializer, json} defp serializer(_, nil), do: {V1.JSONSerializer, nil} defp serializer(_, batch) when is_list(batch) do {V1.JSONSerializer, for(msg <- batch, do: Map.delete(msg, "join_ref"))} end defp serializer(_, %{} = json) do {V1.JSONSerializer, json} end defp decode_body(serializer, %{} = resp) do resp |> update_in([:body], &Phoenix.json_library().decode!(&1)) |> update_in([:body, "messages"], fn messages -> for msg <- messages || [] do serializer.decode!(msg, opcode: :text) end end) end defp encode(_vsn, nil), do: "" defp encode(V2.JSONSerializer = serializer, batch) when is_list(batch) do batch |> Enum.map(&encode(serializer, &1)) |> Enum.join("\n") end defp encode(V2.JSONSerializer, %{} = map) do case map["payload"] do {:binary, data} -> %{"topic" => topic, "event" => event, "join_ref" => join_ref, "ref" => ref} = map ref = to_string(ref) ref_size = byte_size(ref) join_ref = to_string(join_ref) join_ref_size = byte_size(join_ref) topic_size = byte_size(topic) event_size = byte_size(event) Base.encode64(<< 0::size(8), join_ref_size::size(8), ref_size::size(8), topic_size::size(8), event_size::size(8), join_ref::binary-size(join_ref_size), ref::binary-size(ref_size), topic::binary-size(topic_size), event::binary-size(event_size), data::binary >>) _ -> Phoenix.json_library().encode!([ map["join_ref"], map["ref"], map["topic"], map["event"], map["payload"] ]) end end defp encode(V1.JSONSerializer, %{} = map), do: Phoenix.json_library().encode!(map) @doc """ Joins a long poll socket. Returns the long polling session token. If the mode is local, the session will point to a local process. If the mode is pubsub, the session will use the pubsub system. """ def join( path, topic, vsn, join_ref, mode \\ :local, payload \\ %{}, params \\ %{}, headers \\ %{} ) def join(path, topic, vsn, join_ref, :local, payload, params, headers) do resp = poll(:get, path, vsn, params, %{}, headers) assert resp.body["token"] assert resp.body["status"] == 410 assert resp.status == 200 session = resp.body |> Map.take(["token"]) |> Map.merge(params) resp = poll( :post, path, vsn, session, %{ "topic" => topic, "event" => "phx_join", "ref" => "1", "join_ref" => join_ref, "payload" => payload }, headers ) assert resp.body["status"] == 200 session end def join(path, topic, vsn, join_ref, :pubsub, payload, params, headers) do session = join(path, topic, vsn, join_ref, :local, payload, params, headers) {:ok, {:v1, _id, pid, topic}} = Phoenix.Token.verify(Endpoint, Atom.to_string(__MODULE__), session["token"]) %{ "token" => Phoenix.Token.sign(Endpoint, Atom.to_string(__MODULE__), {:v1, "unknown", pid, topic}) } end for %{adapter: adapter} <- [ %{adapter: Bandit.PhoenixAdapter}, %{adapter: Phoenix.Endpoint.Cowboy2Adapter} ] do describe "adapter: #{inspect(adapter)}" do @describetag adapter: adapter for mode <- [:local, :pubsub] do @mode mode @vsn "1.0.0" test "#{@mode}: joins and poll messages" do session = join("/ws", "room:lobby", @vsn, "1", @mode) # pull messages resp = poll(:get, "/ws", @vsn, session) assert resp.body["status"] == 200 [phx_reply, user_entered, status_msg] = resp.body["messages"] assert phx_reply == %Message{ event: "phx_reply", payload: %{"response" => %{}, "status" => "ok"}, ref: "1", topic: "room:lobby" } assert %Message{ event: "joined", payload: %{"status" => "connected", "user_id" => nil}, ref: nil, join_ref: nil, topic: "room:lobby" } = status_msg assert user_entered == %Message{ event: "user_entered", payload: %{"user" => nil}, ref: nil, join_ref: nil, topic: "room:lobby" } # poll without messages sends 204 no_content resp = poll(:get, "/ws", @vsn, session) assert resp.body["status"] == 204 end test "#{@mode}: transport x_headers are extracted to the socket connect_info" do session = join("/ws/connect_info", "room:lobby", @vsn, "1", @mode, %{}, %{}, %{ "x-application" => "Phoenix" }) # pull messages resp = poll(:get, "/ws/connect_info", @vsn, session) assert resp.body["status"] == 200 [_phx_reply, _user_entered, status_msg] = resp.body["messages"] assert %{"connect_info" => %{"x_headers" => %{"x-application" => "Phoenix"}}} = status_msg.payload end test "#{@mode}: transport trace_context_headers are extracted to the socket connect_info" do ctx_headers = %{ "traceparent" => "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01", "tracestate" => "congo=t61rcWkgMz" } session = join("/ws/connect_info", "room:lobby", @vsn, "1", @mode, %{}, %{}, ctx_headers) # pull messages resp = poll(:get, "/ws/connect_info", @vsn, session) assert resp.body["status"] == 200 [_phx_reply, _user_entered, status_msg] = resp.body["messages"] assert %{"connect_info" => %{"trace_context_headers" => ^ctx_headers}} = status_msg.payload end test "#{@mode}: transport peer_data is extracted to the socket connect_info" do session = join("/ws/connect_info", "room:lobby", @vsn, "1", @mode, %{}, %{}, %{ "x-application" => "Phoenix" }) # pull messages resp = poll(:get, "/ws/connect_info", @vsn, session) assert resp.body["status"] == 200 [_phx_reply, _user_entered, status_msg] = resp.body["messages"] assert %{"connect_info" => %{"peer_data" => %{"address" => "127.0.0.1"}}} = status_msg.payload end test "#{@mode}: transport uri is extracted to the socket connect_info" do session = join("/ws/connect_info", "room:lobby", @vsn, "1", @mode, %{}, %{}, %{ "x-application" => "Phoenix" }) # pull messages resp = poll(:get, "/ws/connect_info", @vsn, session) assert resp.body["status"] == 200 [_phx_reply, _user_entered, status_msg] = resp.body["messages"] query = "vsn=#{@vsn}" assert %{ "connect_info" => %{ "uri" => %{ "host" => "127.0.0.1", "path" => "/ws/connect_info/longpoll", "query" => ^query, "scheme" => "http" } } } = status_msg.payload end test "#{@mode}: publishing events" do Phoenix.PubSub.subscribe(__MODULE__, "room:lobby") join_ref = "1" session = join("/ws", "room:lobby", @vsn, join_ref, @mode) # Publish successfully resp = poll(:post, "/ws", @vsn, session, %{ "topic" => "room:lobby", "event" => "new_msg", "ref" => "1", "join_ref" => join_ref, "payload" => %{"body" => "hi!"} }) assert resp.body["status"] == 200 assert_receive %Broadcast{event: "new_msg", payload: %{"body" => "hi!"}} # Get published message resp = poll(:get, "/ws", @vsn, session) assert resp.body["status"] == 200 assert List.last(resp.body["messages"]) == %Message{ event: "new_msg", payload: %{"transport" => ":longpoll", "body" => "hi!"}, ref: nil, join_ref: nil, topic: "room:lobby" } # Publish event to an unjoined room capture_log(fn -> Phoenix.PubSub.subscribe(__MODULE__, "room:private-room") resp = poll(:post, "/ws", @vsn, session, %{ "topic" => "room:private-room", "event" => "new_msg", "ref" => "12300", "payload" => %{"body" => "this method shouldn't send!'"} }) assert resp.body["status"] == 200 refute_receive %Broadcast{event: "new_msg"} # Get join error resp = poll(:get, "/ws", @vsn, session) assert resp.body["status"] == 200 assert List.last(resp.body["messages"]) == %Message{ join_ref: nil, event: "phx_reply", payload: %{ "response" => %{"reason" => "unmatched topic"}, "status" => "error" }, ref: "12300", topic: "room:private-room" } end) end test "#{@mode}: lonpoll publishing batch events on v2 protocol" do vsn = "2.0.0" Phoenix.PubSub.subscribe(__MODULE__, "room:lobby") session = join("/ws", "room:lobby", vsn, "1", @mode) # Publish successfully resp = poll(:post, "/ws", vsn, session, [ %{ "topic" => "room:lobby", "event" => "new_msg", "ref" => "2", "join_ref" => "1", "payload" => %{"body" => "hi1"} }, %{ "topic" => "room:lobby", "event" => "new_msg", "ref" => "3", "join_ref" => "1", "payload" => %{"body" => "hi2"} } ]) assert resp.body["status"] == 200 assert_receive %Broadcast{event: "new_msg", payload: %{"body" => "hi1"}} assert_receive %Broadcast{event: "new_msg", payload: %{"body" => "hi2"}} # Publish base64 binary successfully resp = poll(:post, "/ws", vsn, session, [ %{ "topic" => "room:lobby", "event" => "bin", "join_ref" => "1", "ref" => "4", "payload" => {:binary, <<1, 2, 3>>} }, %{ "topic" => "room:lobby", "event" => "new_msg", "ref" => "5", "join_ref" => "1", "payload" => %{"body" => "hi3"} } ]) assert resp.body["status"] == 200 assert_receive %Broadcast{event: "bin_ack", payload: %{}} assert_receive %Broadcast{event: "new_msg", payload: %{"body" => "hi3"}} # Get published message resp = poll(:get, "/ws", vsn, session) assert resp.body["status"] == 200 assert [ _phx_reply, _user_entered, _joined, %Message{ topic: "room:lobby", event: "new_msg", payload: %{"body" => "hi1", "transport" => ":longpoll"}, ref: nil, join_ref: "1" }, %Message{ topic: "room:lobby", event: "new_msg", payload: %{"body" => "hi2", "transport" => ":longpoll"}, ref: nil, join_ref: "1" }, %Message{ topic: "room:lobby", event: "bin_ack", payload: %{"transport" => ":longpoll"}, ref: nil, join_ref: "1" }, %Message{ topic: "room:lobby", event: "new_msg", payload: %{"body" => "hi3", "transport" => ":longpoll"}, ref: nil, join_ref: "1" } ] = resp.body["messages"] end test "#{@mode}: shuts down after timeout" do session = join("/ws", "room:lobby", @vsn, "1", @mode) channel = Process.whereis(:"room:lobby") assert channel Process.monitor(channel) assert_receive({:DOWN, _, :process, ^channel, {:shutdown, :inactive}}, 5000) resp = poll(:post, "/ws", @vsn, session) assert resp.body["status"] == 410 end end end for {serializer, vsn, join_ref} <- [ {V1.JSONSerializer, "1.0.0", nil}, {V2.JSONSerializer, "2.0.0", "1"} ] do @vsn vsn @join_ref join_ref describe "adapter: #{inspect(adapter)} - with #{vsn} serializer #{inspect(serializer)}" do @describetag adapter: adapter test "refuses connects that error with 403 response" do resp = poll(:get, "/ws", @vsn, %{"reject" => "true"}, %{}) assert resp.body["status"] == 403 resp = poll(:get, "/ws", @vsn, %{"custom_error" => "true"}, %{}) assert resp.body["status"] == 403 end test "refuses unallowed origins" do capture_log(fn -> resp = poll(:get, "/ws", @vsn, %{}, nil, %{"origin" => "https://example.com"}) assert resp.body["status"] == 410 resp = poll(:get, "/ws", @vsn, %{}, nil, %{"origin" => "http://notallowed.com"}) assert resp.body["status"] == 403 end) end test "filter params on join" do log = capture_log(fn -> join( "/ws", "room:lobby", @vsn, @join_ref, :local, %{"foo" => "bar", "password" => "shouldnotshow"}, %{"logging" => "enabled"} ) end) assert log =~ "Parameters: %{\"foo\" => \"bar\", \"password\" => \"[FILTERED]\"}" end test "sends phx_error if a channel server abnormally exits", %{topic: topic} do session = join("/ws", topic, @vsn, @join_ref) capture_log(fn -> resp = poll(:post, "/ws", @vsn, session, %{ "topic" => topic, "event" => "boom", "ref" => @join_ref, "join_ref" => @join_ref, "payload" => %{} }) assert resp.body["status"] == 200 assert resp.status == 200 end) assert_down(topic) resp = poll(:get, "/ws", @vsn, session) [_phx_reply, _user_entered, _joined, chan_error] = resp.body["messages"] assert chan_error == %Message{ event: "phx_error", payload: %{}, topic: topic, ref: @join_ref, join_ref: @join_ref } end test "sends phx_close if a channel server normally exits" do session = join("/ws", "room:lobby", @vsn, @join_ref) resp = poll(:post, "/ws", @vsn, session, %{ "topic" => "room:lobby", "event" => "phx_leave", "join_ref" => @join_ref, "ref" => "2", "payload" => %{} }) assert resp.body["status"] == 200 assert resp.status == 200 resp = poll(:get, "/ws", @vsn, session) [_phx_reply, _joined, _user_entered, _leave_reply, phx_close] = resp.body["messages"] assert phx_close == %Message{ event: "phx_close", payload: %{}, ref: @join_ref, join_ref: @join_ref, topic: "room:lobby" } end test "shuts down when receiving disconnect broadcasts on socket's id" do resp = poll(:get, "/ws", @vsn, %{"user_id" => "456"}, %{}) session = Map.take(resp.body, ["token"]) for topic <- ["room:lpdisconnect1", "room:lpdisconnect2"] do poll(:post, "/ws", @vsn, session, %{ "topic" => topic, "event" => "phx_join", "ref" => "1", "payload" => %{} }) end chan1 = Process.whereis(:"room:lpdisconnect1") assert chan1 chan2 = Process.whereis(:"room:lpdisconnect2") assert chan2 Process.monitor(chan1) Process.monitor(chan2) Endpoint.broadcast("user_sockets:456", "disconnect", %{}) assert_receive {:DOWN, _, :process, ^chan1, {:shutdown, :disconnected}} assert_receive {:DOWN, _, :process, ^chan2, {:shutdown, :disconnected}} poll(:get, "/ws", @vsn, session) assert resp.body["status"] == 410 end test "refuses non-matching versions" do log = capture_log(fn -> resp = poll(:get, "/ws", "123.1.1", %{}, nil, %{"origin" => "https://example.com"}) assert resp.body["status"] == 403 end) assert log =~ "The client's requested transport version \"123.1.1\" does not match server's version" end test "forces application/json content-type" do session = join("/ws", "room:lobby", @vsn, @join_ref) resp = poll( :post, "/ws", @vsn, session, %{ "topic" => "room:lobby", "event" => "phx_leave", "ref" => "2", "join_ref" => @join_ref, "payload" => %{} }, %{"content-type" => ""} ) assert resp.body["status"] == 200 assert resp.status == 200 end end end end end ================================================ FILE: test/phoenix/integration/long_poll_socket_test.exs ================================================ Code.require_file("../../support/http_client.exs", __DIR__) defmodule Phoenix.Integration.LongPollSocketTest do # TODO: use parameterized tests once we require Elixir 1.18 use ExUnit.Case import ExUnit.CaptureLog alias Phoenix.Integration.HTTPClient alias __MODULE__.Endpoint @moduletag :capture_log @port 5908 @pool_size 1 Application.put_env( :phoenix, Endpoint, https: false, http: [port: @port], debug_errors: false, secret_key_base: String.duplicate("abcdefgh", 8), server: true, drainer: false, pubsub_server: __MODULE__ ) defmodule UserSocket do @behaviour Phoenix.Socket.Transport def child_spec(opts) do :value = Keyword.fetch!(opts, :custom) :ignore end def connect(map) do %{endpoint: Endpoint, params: params, transport: :longpoll} = map {:ok, {:params, params}} end def init({:params, _} = state) do {:ok, state} end def handle_in({"params", opts}, {:params, params} = state) do :text = Keyword.fetch!(opts, :opcode) {:reply, :ok, {:text, inspect(params)}, state} end def handle_in({"ping", opts}, state) do :text = Keyword.fetch!(opts, :opcode) send(self(), :ping) {:ok, state} end def handle_info(:ping, state) do {:push, {:text, "pong"}, state} end def terminate(_reason, {:params, _}) do :ok end end defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix socket "/ws", UserSocket, longpoll: [window_ms: 200, pubsub_timeout_ms: 200, check_origin: ["//example.com"]], custom: :value socket "/custom/:socket_var", UserSocket, longpoll: [path: ":path_var/path", check_origin: ["//example.com"], pubsub_timeout_ms: 200], custom: :value end setup %{adapter: adapter} do config = Application.get_env(:phoenix, Endpoint) Application.put_env(:phoenix, Endpoint, Keyword.merge(config, adapter: adapter)) capture_log(fn -> start_supervised!(Endpoint) end) start_supervised!({Phoenix.PubSub, name: __MODULE__, pool_size: @pool_size}) :ok end setup do for {_, pid, _, _} <- DynamicSupervisor.which_children(Phoenix.Transports.LongPoll.Supervisor) do DynamicSupervisor.terminate_child(Phoenix.Transports.LongPoll.Supervisor, pid) end :ok end def poll(method, path, params, body \\ nil, headers \\ %{}) do headers = Map.merge(%{"content-type" => "application/json"}, headers) url = "http://127.0.0.1:#{@port}/#{path}?" <> URI.encode_query(params) {:ok, resp} = HTTPClient.request(method, url, headers, body) update_in(resp.body, &Phoenix.json_library().decode!(&1)) end for %{adapter: adapter} <- [ %{adapter: Bandit.PhoenixAdapter}, %{adapter: Phoenix.Endpoint.Cowboy2Adapter} ] do describe "adapter: #{inspect(adapter)}" do @describetag adapter: adapter test "refuses unallowed origins" do capture_log(fn -> resp = poll(:get, "ws/longpoll", %{}, nil, %{"origin" => "https://example.com"}) assert resp.body["status"] == 410 resp = poll(:get, "ws/longpoll", %{}, nil, %{"origin" => "http://notallowed.com"}) assert resp.body["status"] == 403 end) end test "returns params with sync request" do resp = poll(:get, "ws/longpoll", %{"hello" => "world"}, nil) assert resp.body["token"] assert resp.body["status"] == 410 assert resp.status == 200 secret = Map.take(resp.body, ["token"]) resp = poll(:post, "ws/longpoll", secret, "params") assert resp.body["status"] == 200 resp = poll(:get, "ws/longpoll", secret, nil) assert resp.body["messages"] == [~s(%{"hello" => "world"})] end test "allows a path with variables" do path = "custom/123/456/path" resp = poll(:get, path, %{"key" => "value"}, nil) secret = Map.take(resp.body, ["token"]) resp = poll(:post, path, secret, "params") assert resp.body["status"] == 200 resp = poll(:get, path, secret, nil) [params] = resp.body["messages"] assert params =~ ~s("key" => "value") assert params =~ ~s("socket_var" => "123") assert params =~ ~s(path_var" => "456") end test "returns pong from async request" do resp = poll(:get, "ws/longpoll", %{"hello" => "world"}, nil) assert resp.body["token"] assert resp.body["status"] == 410 assert resp.status == 200 secret = Map.take(resp.body, ["token"]) resp = poll(:post, "ws/longpoll", secret, "ping") assert resp.body["status"] == 200 resp = poll(:get, "ws/longpoll", secret, nil) assert resp.body["messages"] == ["pong"] end end end end ================================================ FILE: test/phoenix/integration/websocket_channels_test.exs ================================================ Code.require_file("../../support/websocket_client.exs", __DIR__) defmodule Phoenix.Integration.WebSocketChannelsTest do # TODO: use parameterized tests once we require Elixir 1.18 use ExUnit.Case import ExUnit.CaptureLog alias Phoenix.Integration.WebsocketClient alias Phoenix.Socket.{V1, V2, Message} alias __MODULE__.Endpoint @moduletag :capture_log @port 5807 Application.put_env(:phoenix, Endpoint, https: false, http: [port: @port], debug_errors: false, server: true, drainer: false, pubsub_server: __MODULE__, secret_key_base: String.duplicate("a", 64) ) defp lobby do "room:lobby#{System.unique_integer()}" end defmodule RoomChannel do use Phoenix.Channel intercept ["new_msg"] def join(topic, message, socket) do Process.register(self(), String.to_atom(topic)) send(self(), {:after_join, message}) {:ok, socket} end def handle_info({:after_join, message}, socket) do broadcast(socket, "user_entered", %{user: message["user"]}) push(socket, "joined", Map.merge(%{status: "connected"}, socket.assigns)) {:noreply, socket} end def handle_in("new_msg", message, socket) do broadcast!(socket, "new_msg", message) {:reply, :ok, socket} end def handle_in("boom", _message, _socket) do raise "boom" end def handle_in("binary_event", {:binary, data}, socket) do push(socket, "binary_event", {:binary, <<0, 1>>}) {:reply, {:ok, {:binary, <>}}, socket} end def handle_out("new_msg", payload, socket) do push(socket, "new_msg", Map.put(payload, "transport", inspect(socket.transport))) {:noreply, socket} end def terminate(_reason, socket) do push(socket, "you_left", %{message: "bye!"}) :ok end end defmodule CustomChannel do use GenServer, restart: :temporary def start_link(from) do GenServer.start_link(__MODULE__, from) end def init({_, _}) do {:ok, :init} end def handle_info({Phoenix.Channel, payload, from, socket}, :init) do case payload["action"] do "ok" -> GenServer.reply(from, {:ok, %{"action" => "ok"}}) {:noreply, socket} "ignore" -> GenServer.reply(from, {:error, %{"action" => "ignore"}}) send(self(), :stop) {:noreply, socket} "error" -> raise "oops" end end def handle_info(%Message{event: "close"}, socket) do send(socket.transport_pid, {:socket_close, self(), :shutdown}) {:stop, :shutdown, socket} end def handle_info(:stop, socket) do {:stop, :shutdown, socket} end end defmodule UserSocketConnectInfo do use Phoenix.Socket, log: false channel "room:*", RoomChannel def connect(params, socket, connect_info) do unless params["logging"] == "enabled", do: Logger.put_process_level(self(), :none) address = Tuple.to_list(connect_info.peer_data.address) |> Enum.join(".") connect_info = connect_info |> Map.update!(:peer_data, &Map.put(&1, :address, address)) |> Map.update!(:trace_context_headers, &Map.new/1) |> Map.update!(:uri, &Map.from_struct/1) |> Map.update!(:x_headers, &Map.new/1) |> Map.update!(:sec_websocket_headers, &Map.new/1) socket = socket |> assign(:user_id, params["user_id"]) |> assign(:connect_info, connect_info) {:ok, socket} end def id(socket) do if id = socket.assigns.user_id, do: "user_sockets:#{id}" end end defmodule UserSocket do use Phoenix.Socket channel "room:*", RoomChannel channel "custom:*", CustomChannel def connect(%{"reject" => "true"}, _socket) do :error end def connect(%{"ratelimit" => "true"}, _socket) do {:error, :rate_limit} end def connect(params, socket) do unless params["logging"] == "enabled", do: Logger.put_process_level(self(), :none) {:ok, assign(socket, :user_id, params["user_id"])} end def id(socket) do if id = socket.assigns.user_id, do: "user_sockets:#{id}" end def handle_error(conn, :rate_limit), do: Plug.Conn.send_resp(conn, 429, "Too many requests") end defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix @session_config store: :cookie, key: "_hello_key", signing_salt: "change_me" socket "/ws", UserSocket, websocket: [ check_origin: ["//example.com"], timeout: 200, error_handler: {UserSocket, :handle_error, []} ] socket "/ws/admin", UserSocket, websocket: [ check_origin: ["//example.com"], timeout: 200 ] socket "/ws/connect_info", UserSocketConnectInfo, websocket: [ check_origin: ["//example.com"], timeout: 200, connect_info: [ :trace_context_headers, :x_headers, :peer_data, :uri, :user_agent, :sec_websocket_headers, session: @session_config, signing_salt: "salt" ] ] plug Plug.Session, @session_config plug :fetch_session plug Plug.CSRFProtection plug :put_session defp put_session(conn, _) do conn |> put_session(:from_session, "123") |> send_resp(200, Plug.CSRFProtection.get_csrf_token()) end end setup %{adapter: adapter} do config = Application.get_env(:phoenix, Endpoint) Application.put_env(:phoenix, Endpoint, Keyword.merge(config, adapter: adapter)) capture_log(fn -> start_supervised!(Endpoint) end) start_supervised!({Phoenix.PubSub, name: __MODULE__}) :ok end @endpoint Endpoint for %{adapter: adapter} <- [ %{adapter: Bandit.PhoenixAdapter}, %{adapter: Phoenix.Endpoint.Cowboy2Adapter} ] do for {serializer, vsn, join_ref} <- [ {V1.JSONSerializer, "1.0.0", nil}, {V2.JSONSerializer, "2.0.0", "11"} ] do @serializer serializer @vsn vsn @vsn_path "ws://127.0.0.1:#{@port}/ws/websocket?vsn=#{@vsn}" @join_ref join_ref describe "adapter: #{inspect(adapter)} - with #{vsn} serializer #{inspect(serializer)}" do @describetag adapter: adapter test "endpoint handles multiple mount segments" do {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/admin/websocket?vsn=#{@vsn}", @serializer ) WebsocketClient.join(sock, "room:admin-lobby1", %{}) assert_receive %Message{ event: "phx_reply", payload: %{"response" => %{}, "status" => "ok"}, join_ref: @join_ref, ref: "1", topic: "room:admin-lobby1" } end test "join, leave, and event messages" do {:ok, sock} = WebsocketClient.connect(self(), @vsn_path, @serializer) lobby = lobby() WebsocketClient.join(sock, lobby, %{}) assert_receive %Message{ event: "phx_reply", join_ref: @join_ref, payload: %{"response" => %{}, "status" => "ok"}, ref: "1", topic: ^lobby } assert_receive %Message{ event: "joined", join_ref: @join_ref, payload: %{"status" => "connected", "user_id" => nil} } assert_receive %Message{ event: "user_entered", payload: %{"user" => nil}, join_ref: nil, ref: nil, topic: ^lobby } channel_pid = Process.whereis(String.to_atom(lobby)) assert channel_pid assert Process.alive?(channel_pid) WebsocketClient.send_event(sock, lobby, "new_msg", %{body: "hi!"}) assert_receive %Message{ event: "new_msg", payload: %{"transport" => ":websocket", "body" => "hi!"} } WebsocketClient.leave(sock, lobby, %{}) assert_receive %Message{event: "you_left", payload: %{"message" => "bye!"}} assert_receive %Message{event: "phx_reply", payload: %{"status" => "ok"}} assert_receive %Message{event: "phx_close", payload: %{}} refute Process.alive?(channel_pid) WebsocketClient.send_event(sock, lobby, "new_msg", %{body: "Should ignore"}) refute_receive %Message{event: "new_msg"} assert_receive %Message{ event: "phx_reply", payload: %{"response" => %{"reason" => "unmatched topic"}} } WebsocketClient.send_event(sock, lobby, "new_msg", %{body: "Should ignore"}) refute_receive %Message{event: "new_msg"} end test "transport x_headers are extracted to the socket connect_info" do extra_headers = [{"x-application", "Phoenix"}] {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}", @serializer, extra_headers ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{"connect_info" => %{"x_headers" => %{"x-application" => "Phoenix"}}} } end test "transport sec-websocket-* headers are extracted to the socket connect_info" do extra_headers = [ {"sec-websocket-protocol", "phoenix, 123"}, {"sec-websocket-extensions", "permessage-deflate; client_max_window_bits=15"} ] {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}", @serializer, extra_headers ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{ "connect_info" => %{ "sec_websocket_headers" => %{ "sec-websocket-protocol" => "phoenix, 123", "sec-websocket-extensions" => "permessage-deflate; client_max_window_bits=15" } } } } end test "transport trace_context_headers are extracted to the socket connect_info" do extra_headers = [ {"traceparent", "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01"}, {"tracestate", "congo=t61rcWkgMzE"} ] {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}", @serializer, extra_headers ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{ "connect_info" => %{ "trace_context_headers" => %{ "traceparent" => "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01", "tracestate" => "congo=t61rcWkgMzE" } } } } end test "transport peer_data is extracted to the socket connect_info" do {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}", @serializer ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{ "connect_info" => %{ "peer_data" => %{"address" => "127.0.0.1", "port" => _, "ssl_cert" => nil} } } } end test "transport uri is extracted to the socket connect_info" do {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}", @serializer ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{ "connect_info" => %{ "uri" => %{ "host" => "127.0.0.1", "path" => "/ws/connect_info/websocket", "query" => "vsn=#{@vsn}", "scheme" => "http", "port" => @port } } } } end test "transport user agent is extracted to the socket connect_info" do extra_headers = [{"user-agent", "foo/1.0"}] {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}", @serializer, extra_headers ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{ "connect_info" => %{ "user_agent" => "foo/1.0" } } } end test "transport session is extracted to the socket connect_info" do import Phoenix.ConnTest path = "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}" # GET the cookie and CSRF token conn = get(build_conn(), "/") extra_headers = [{"cookie", "_hello_key=" <> conn.resp_cookies["_hello_key"].value}] csrf_token_query = "&_csrf_token=" <> URI.encode_www_form(conn.resp_body) # It works with headers and cookie {:ok, sock} = WebsocketClient.connect(self(), path <> csrf_token_query, @serializer, extra_headers) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{ "connect_info" => %{"session" => %{"from_session" => "123", "_csrf_token" => _}} } } # It doesn't work without headers {:ok, sock} = WebsocketClient.connect(self(), path <> csrf_token_query, @serializer) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{"connect_info" => %{"session" => nil}} } # It doesn't work with invalid csrf token {:ok, sock} = WebsocketClient.connect( self(), path <> "&_csrf_token=bad", @serializer, extra_headers ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{"connect_info" => %{"session" => nil}} } end test "transport custom keywords are extracted to the socket connect_info" do {:ok, sock} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/connect_info/websocket?vsn=#{@vsn}", @serializer ) WebsocketClient.join(sock, lobby(), %{}) assert_receive %Message{ event: "joined", payload: %{"connect_info" => %{"signing_salt" => "salt"}} } end test "logs user socket connect when enabled" do log = capture_log(fn -> {:ok, _} = WebsocketClient.connect(self(), "#{@vsn_path}&logging=enabled", @serializer) end) assert log =~ "CONNECTED TO Phoenix.Integration.WebSocketChannelsTest.UserSocket in " assert log =~ " Transport: :websocket" assert log =~ " Serializer: #{inspect(@serializer)}" assert log =~ " Parameters: %{\"logging\" => \"enabled\", \"vsn\" => #{inspect(@vsn)}}" end test "does not log user socket connect when disabled" do log = capture_log(fn -> {:ok, _} = WebsocketClient.connect(self(), @vsn_path, @serializer) end) assert log == "" end test "logs and filter params on join and handle_in" do topic = "room:admin-lobby2" {:ok, sock} = WebsocketClient.connect(self(), "#{@vsn_path}&logging=enabled", @serializer) log = capture_log(fn -> WebsocketClient.join(sock, topic, %{"join" => "yes", "password" => "no"}) assert_receive %Message{ event: "phx_reply", join_ref: @join_ref, payload: %{"response" => %{}, "status" => "ok"}, ref: "1", topic: "room:admin-lobby2" } end) assert log =~ "JOINED room:admin-lobby2 in " assert log =~ "Parameters: %{\"join\" => \"yes\", \"password\" => \"[FILTERED]\"}" log = capture_log(fn -> WebsocketClient.send_event(sock, topic, "new_msg", %{ "in" => "yes", "password" => "no" }) assert_receive %Message{event: "phx_reply", ref: "2"} end) assert log =~ "HANDLED new_msg INCOMING ON room:admin-lobby2 (Phoenix.Integration.WebSocketChannelsTest.RoomChannel)" assert log =~ "Parameters: %{\"in\" => \"yes\", \"password\" => \"[FILTERED]\"}" end test "sends phx_error if a channel server abnormally exits" do {:ok, sock} = WebsocketClient.connect(self(), @vsn_path, @serializer) lobby = lobby() WebsocketClient.join(sock, lobby, %{}) assert_receive %Message{ event: "phx_reply", ref: "1", payload: %{"response" => %{}, "status" => "ok"} } assert_receive %Message{event: "joined"} assert_receive %Message{event: "user_entered"} capture_log(fn -> WebsocketClient.send_event(sock, lobby, "boom", %{}) assert_receive %Message{event: "phx_error", payload: %{}, topic: ^lobby} end) end test "channels are terminated if transport normally exits" do {:ok, sock} = WebsocketClient.connect(self(), @vsn_path, @serializer) lobby = lobby() WebsocketClient.join(sock, lobby, %{}) assert_receive %Message{ event: "phx_reply", ref: "1", payload: %{"response" => %{}, "status" => "ok"} } assert_receive %Message{event: "joined"} channel = Process.whereis(String.to_atom(lobby)) assert channel Process.monitor(channel) WebsocketClient.close(sock) assert_receive {:DOWN, _, :process, ^channel, shutdown} when shutdown in [ :shutdown, {:shutdown, :closed}, {:shutdown, :local_closed} ] end test "refuses websocket events that haven't joined" do {:ok, sock} = WebsocketClient.connect(self(), @vsn_path, @serializer) WebsocketClient.send_event(sock, lobby(), "new_msg", %{body: "hi!"}) refute_receive %Message{event: "new_msg"} assert_receive %Message{ event: "phx_reply", payload: %{"response" => %{"reason" => "unmatched topic"}} } WebsocketClient.send_event(sock, lobby(), "new_msg", %{body: "Should ignore"}) refute_receive %Message{event: "new_msg"} end test "refuses unallowed origins" do capture_log(fn -> assert {:ok, _} = WebsocketClient.connect(self(), @vsn_path, @serializer, [ {"origin", "https://example.com"} ]) assert {:error, %Mint.WebSocket.UpgradeFailureError{status_code: 403}} = WebsocketClient.connect(self(), @vsn_path, @serializer, [ {"origin", "http://notallowed.com"} ]) end) end test "refuses connects that error with 403 response" do assert {:error, %Mint.WebSocket.UpgradeFailureError{status_code: 403}} = WebsocketClient.connect(self(), "#{@vsn_path}&reject=true", @serializer) end test "refuses connects that error with custom error response" do assert {:error, %Mint.WebSocket.UpgradeFailureError{status_code: 429}} = WebsocketClient.connect(self(), "#{@vsn_path}&ratelimit=true", @serializer) end test "shuts down when receiving disconnect broadcasts on socket's id" do {:ok, sock} = WebsocketClient.connect(self(), "#{@vsn_path}&user_id=1001", @serializer) WebsocketClient.join(sock, "room:wsdisconnect1", %{}) assert_receive %Message{ topic: "room:wsdisconnect1", event: "phx_reply", ref: "1", payload: %{"response" => %{}, "status" => "ok"} } WebsocketClient.join(sock, "room:wsdisconnect2", %{}) assert_receive %Message{ topic: "room:wsdisconnect2", event: "phx_reply", ref: "2", payload: %{"response" => %{}, "status" => "ok"} } chan1 = Process.whereis(:"room:wsdisconnect1") assert chan1 chan2 = Process.whereis(:"room:wsdisconnect2") assert chan2 Process.monitor(sock) Process.monitor(chan1) Process.monitor(chan2) Endpoint.broadcast("user_sockets:1001", "disconnect", %{}) assert_receive {:DOWN, _, :process, ^sock, :normal} assert_receive {:DOWN, _, :process, ^chan1, shutdown} # :shutdown for cowboy, {:shutdown, :closed} for cowboy 2, {:shutdown, :disconnected} # for bandit assert shutdown in [:shutdown, {:shutdown, :closed}, {:shutdown, :disconnected}] assert_receive {:DOWN, _, :process, ^chan2, shutdown} assert shutdown in [:shutdown, {:shutdown, :closed}, {:shutdown, :disconnected}] end test "duplicate join event closes existing channel" do {:ok, sock} = WebsocketClient.connect(self(), "#{@vsn_path}&user_id=1001", @serializer) WebsocketClient.join(sock, "room:joiner", %{}) assert_receive %Message{ topic: "room:joiner", event: "phx_reply", ref: "1", payload: %{"response" => %{}, "status" => "ok"} } WebsocketClient.join(sock, "room:joiner", %{}) assert_receive %Message{ topic: "room:joiner", event: "phx_reply", ref: "2", payload: %{"response" => %{}, "status" => "ok"} } end test "returns 403 when versions to not match" do assert capture_log(fn -> url = "ws://127.0.0.1:#{@port}/ws/websocket?vsn=123.1.1" assert {:error, %Mint.WebSocket.UpgradeFailureError{status_code: 403}} = WebsocketClient.connect(self(), url, @serializer) end) =~ "The client's requested transport version \"123.1.1\" does not match server's version" end test "shuts down if client goes quiet" do {:ok, socket} = WebsocketClient.connect(self(), @vsn_path, @serializer) Process.monitor(socket) WebsocketClient.send_heartbeat(socket) assert_receive %Message{ event: "phx_reply", payload: %{"response" => %{}, "status" => "ok"}, ref: "1", topic: "phoenix" } assert_receive {:DOWN, _, :process, ^socket, :normal}, 400 end test "warns for unmatched topic" do {:ok, sock} = WebsocketClient.connect(self(), "#{@vsn_path}&logging=enabled", @serializer) log = capture_log(fn -> WebsocketClient.join(sock, "unmatched-topic", %{}) assert_receive %Message{ event: "phx_reply", ref: "1", topic: "unmatched-topic", join_ref: nil, payload: %{ "status" => "error", "response" => %{"reason" => "unmatched topic"} } } end) assert log =~ "Ignoring unmatched topic \"unmatched-topic\" in Phoenix.Integration.WebSocketChannelsTest.UserSocket" end end end # Those tests are not transport specific but for integration purposes # it is best to assert custom channels work throughout the whole stack, # compared to only testing the socket <-> channel communication. Which # is why test them under the latest websocket transport. describe "adapter: #{inspect(adapter)} - custom channels" do @describetag adapter: adapter @serializer V2.JSONSerializer @vsn "2.0.0" @vsn_path "ws://127.0.0.1:#{@port}/ws/websocket?vsn=#{@vsn}" test "join, ignore, error, and event messages" do {:ok, sock} = WebsocketClient.connect(self(), @vsn_path, @serializer) WebsocketClient.join(sock, "custom:ignore", %{"action" => "ignore"}) assert_receive %Message{ event: "phx_reply", join_ref: "11", payload: %{"response" => %{"action" => "ignore"}, "status" => "error"}, ref: "1", topic: "custom:ignore" } WebsocketClient.join(sock, "custom:error", %{"action" => "error"}) assert_receive %Message{ event: "phx_reply", join_ref: "12", payload: %{"response" => %{"reason" => "join crashed"}, "status" => "error"}, ref: "2", topic: "custom:error" } WebsocketClient.join(sock, "custom:ok", %{"action" => "ok"}) assert_receive %Message{ event: "phx_reply", join_ref: "13", payload: %{"response" => %{"action" => "ok"}, "status" => "ok"}, ref: "3", topic: "custom:ok" } WebsocketClient.send_event(sock, "custom:ok", "close", %{body: "bye!"}) assert_receive %Message{event: "phx_close", payload: %{}} end end describe "adapter: #{inspect(adapter)} - binary" do @describetag adapter: adapter @serializer V2.JSONSerializer @vsn "2.0.0" @join_ref "11" test "messages can be pushed and received" do topic = "room:bin" {:ok, socket} = WebsocketClient.connect( self(), "ws://127.0.0.1:#{@port}/ws/websocket?vsn=#{@vsn}", @serializer ) WebsocketClient.join(socket, topic, %{}) assert_receive %Message{ event: "phx_reply", payload: %{"response" => %{}, "status" => "ok"}, join_ref: @join_ref, ref: "1", topic: ^topic } WebsocketClient.send_event(socket, topic, "binary_event", {:binary, <<1, 2>>}) assert_receive %Message{ event: "phx_reply", payload: %{"response" => {:binary, <<1, 2, 3, 4>>}, "status" => "ok"}, join_ref: @join_ref, ref: "2", topic: ^topic } assert_receive %Message{ event: "binary_event", join_ref: @join_ref, payload: {:binary, <<0, 1>>} } end end end end ================================================ FILE: test/phoenix/integration/websocket_socket_test.exs ================================================ Code.require_file("../../support/websocket_client.exs", __DIR__) Code.require_file("../../support/http_client.exs", __DIR__) defmodule Phoenix.Integration.WebSocketTest do # TODO: use parameterized tests once we require Elixir 1.18 use ExUnit.Case import ExUnit.CaptureLog alias Phoenix.Integration.{HTTPClient, WebsocketClient} alias __MODULE__.Endpoint @moduletag :capture_log @port 5907 @path "ws://127.0.0.1:#{@port}/ws/websocket" Application.put_env( :phoenix, Endpoint, https: false, http: [port: @port], debug_errors: false, server: true, drainer: false ) defmodule UserSocket do @behaviour Phoenix.Socket.Transport def child_spec(opts) do :value = Keyword.fetch!(opts, :custom) :ignore end def connect(map) do %{endpoint: Endpoint, params: params, transport: :websocket} = map {:ok, {:params, params}} end def init({:params, _} = state) do {:ok, state} end def handle_in({"params", opts}, {:params, params} = state) do :text = Keyword.fetch!(opts, :opcode) {:reply, :ok, {:text, inspect(params)}, state} end def handle_in({"ping", opts}, state) do :text = Keyword.fetch!(opts, :opcode) send(self(), :ping) {:ok, state} end def handle_info(:ping, state) do {:push, {:text, "pong"}, state} end def terminate(_reason, {:params, _}) do :ok end end defmodule PingSocket do @behaviour Phoenix.Socket.Transport def child_spec(_opts), do: :ignore def connect(_), do: {:ok, %{}} def init(state), do: {:ok, state} def handle_in({"ping:start", _}, state) do {:reply, :ok, {:ping, <<>>}, state} end def handle_in({"ping:start:" <> payload, _}, state) do {:reply, :ok, {:ping, payload}, state} end def handle_info(_, state), do: {:ok, state} def handle_control({payload, opts}, state) do opcode = Keyword.fetch!(opts, :opcode) {:push, {:text, "#{opcode}:#{payload}"}, state} end def terminate(_reason, _state), do: :ok end defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix socket "/ws", UserSocket, websocket: [check_origin: ["//example.com"], subprotocols: ["sip"], timeout: 200], custom: :value socket "/custom/some_path", UserSocket, websocket: [path: "nested/path", check_origin: ["//example.com"], timeout: 200], custom: :value socket "/custom/:socket_var", UserSocket, websocket: [path: ":path_var/path", check_origin: ["//example.com"], timeout: 200], custom: :value socket "/ws/ping", PingSocket, websocket: true end setup %{adapter: adapter} do config = Application.get_env(:phoenix, Endpoint) Application.put_env(:phoenix, Endpoint, Keyword.merge(config, adapter: adapter)) capture_log(fn -> start_supervised!(Endpoint) end) :ok end for %{adapter: adapter} <- [ %{adapter: Bandit.PhoenixAdapter}, %{adapter: Phoenix.Endpoint.Cowboy2Adapter} ] do describe "adapter: #{inspect(adapter)}" do @describetag adapter: adapter test "handles invalid upgrade requests" do capture_log(fn -> path = String.replace_prefix(@path, "ws", "http") assert {:ok, %{body: body, status: 400}} = HTTPClient.request(:get, path, %{}) assert body =~ "'connection' header must contain 'upgrade'" end) end test "refuses unallowed origins" do capture_log(fn -> headers = [{"origin", "https://example.com"}] assert {:ok, _} = WebsocketClient.connect(self(), @path, :noop, headers) headers = [{"origin", "http://notallowed.com"}] assert {:error, %Mint.WebSocket.UpgradeFailureError{status_code: 403}} = WebsocketClient.connect(self(), @path, :noop, headers) end) end test "refuses unallowed Websocket subprotocols" do assert capture_log(fn -> headers = [{"sec-websocket-protocol", "sip"}] assert {:ok, _} = WebsocketClient.connect(self(), @path, :noop, headers) headers = [] assert {:ok, _} = WebsocketClient.connect(self(), @path, :noop, headers) headers = [{"sec-websocket-protocol", "mqtt"}] assert {:error, %Mint.WebSocket.UpgradeFailureError{status_code: 403}} = WebsocketClient.connect(self(), @path, :noop, headers) end) =~ "Could not check Websocket subprotocols" end test "returns params with sync request" do assert {:ok, client} = WebsocketClient.connect(self(), "#{@path}?key=value", :noop) WebsocketClient.send(client, {:text, "params"}) assert_receive {:text, ~s(%{"key" => "value"})} end test "ignores control frames when handle_control/2 is not defined" do assert {:ok, client} = WebsocketClient.connect(self(), @path, :noop) WebsocketClient.send(client, :ping) WebsocketClient.send(client, {:text, "ping"}) assert_receive {:text, "pong"} end test "returns pong from async request" do assert {:ok, client} = WebsocketClient.connect(self(), "#{@path}?key=value", :noop) WebsocketClient.send(client, {:text, "ping"}) assert_receive {:text, "pong"} end test "allows a custom path" do path = "ws://127.0.0.1:#{@port}/custom/some_path/nested/path" assert {:ok, _} = WebsocketClient.connect(self(), "#{path}?key=value", :noop) end test "allows a path with variables" do path = "ws://127.0.0.1:#{@port}/custom/123/456/path" assert {:ok, client} = WebsocketClient.connect(self(), "#{path}?key=value", :noop) WebsocketClient.send(client, {:text, "params"}) assert_receive {:text, params} assert params =~ ~s("key" => "value") assert params =~ ~s("socket_var" => "123") assert params =~ ~s(path_var" => "456") end test "allows using control frames with a payload" do path = "ws://127.0.0.1:#{@port}/ws/ping/websocket" assert {:ok, client} = WebsocketClient.connect(self(), path, :noop) WebsocketClient.send(client, {:ping, ""}) assert_receive {:pong, ""} assert_receive {:text, "ping:"} WebsocketClient.send(client, {:ping, "123"}) assert_receive {:pong, "123"} assert_receive {:text, "ping:123"} WebsocketClient.send(client, {:text, "ping:start"}) assert_receive {:ping, ""} assert_receive {:text, "pong:"} WebsocketClient.send(client, {:text, "ping:start:123"}) assert_receive {:ping, "123"} assert_receive {:text, "pong:123"} end end end end ================================================ FILE: test/phoenix/logger_test.exs ================================================ defmodule Phoenix.LoggerTest do use ExUnit.Case, async: true use RouterHelper describe "filter_values/2 with discard strategy" do test "in top level map" do values = %{"foo" => "bar", "password" => "should_not_show"} assert Phoenix.Logger.filter_values(values, ["password"]) == %{"foo" => "bar", "password" => "[FILTERED]"} assert Phoenix.Logger.filter_values(values, Phoenix.Logger.compile_filter(["password"])) == %{"foo" => "bar", "password" => "[FILTERED]"} end test "when a map has secret key" do values = %{"foo" => "bar", "map" => %{"password" => "should_not_show"}} assert Phoenix.Logger.filter_values(values, ["password"]) == %{"foo" => "bar", "map" => %{"password" => "[FILTERED]"}} end test "when a list has a map with secret" do values = %{"foo" => "bar", "list" => [%{"password" => "should_not_show"}]} assert Phoenix.Logger.filter_values(values, ["password"]) == %{"foo" => "bar", "list" => [%{"password" => "[FILTERED]"}]} end test "does not filter structs" do values = %{"foo" => "bar", "file" => %Plug.Upload{}} assert Phoenix.Logger.filter_values(values, ["password"]) == %{"foo" => "bar", "file" => %Plug.Upload{}} values = %{"foo" => "bar", "file" => %{__struct__: "s"}} assert Phoenix.Logger.filter_values(values, ["password"]) == %{"foo" => "bar", "file" => %{:__struct__ => "s"}} end test "does not fail on atomic keys" do values = %{:foo => "bar", "password" => "should_not_show"} assert Phoenix.Logger.filter_values(values, ["password"]) == %{:foo => "bar", "password" => "[FILTERED]"} end end describe "filter_values/2 with keep strategy" do test "discards values not specified in params" do values = %{"foo" => "bar", "password" => "abc123", "file" => %Plug.Upload{}} assert Phoenix.Logger.filter_values(values, {:keep, []}) == %{"foo" => "[FILTERED]", "password" => "[FILTERED]", "file" => "[FILTERED]"} assert Phoenix.Logger.filter_values(values, Phoenix.Logger.compile_filter({:keep, []})) == %{"foo" => "[FILTERED]", "password" => "[FILTERED]", "file" => "[FILTERED]"} end test "keeps values that are specified in params" do values = %{"foo" => "bar", "password" => "abc123", "file" => %Plug.Upload{}} assert Phoenix.Logger.filter_values(values, {:keep, ["foo", "file"]}) == %{"foo" => "bar", "password" => "[FILTERED]", "file" => %Plug.Upload{}} end test "keeps all values under keys that are kept" do values = %{"foo" => %{"bar" => 1, "baz" => 2}} assert Phoenix.Logger.filter_values(values, {:keep, ["foo"]}) == %{"foo" => %{"bar" => 1, "baz" => 2}} end test "only filters leaf values" do values = %{"foo" => %{"bar" => 1, "baz" => 2}, "ids" => [1, 2]} assert Phoenix.Logger.filter_values(values, {:keep, []}) == %{ "foo" => %{"bar" => "[FILTERED]", "baz" => "[FILTERED]"}, "ids" => ["[FILTERED]", "[FILTERED]"] } end end describe "telemetry" do def log_level(conn) do case conn.path_info do [] -> :debug ["warn" | _] -> :warning ["error" | _] -> :error ["false" | _] -> false _ -> :info end end test "invokes log level callback from Plug.Telemetry" do opts = Plug.Telemetry.init( event_prefix: [:phoenix, :endpoint], log: {__MODULE__, :log_level, []} ) assert ExUnit.CaptureLog.capture_log(fn -> Plug.Telemetry.call(conn(:get, "/"), opts) end) =~ "[debug] GET /" assert ExUnit.CaptureLog.capture_log(fn -> Plug.Telemetry.call(conn(:get, "/warn"), opts) end) =~ ~r"\[warn(ing)?\] ?GET /warn" assert ExUnit.CaptureLog.capture_log(fn -> Plug.Telemetry.call(conn(:get, "/error/404"), opts) end) =~ "[error] GET /error/404" assert ExUnit.CaptureLog.capture_log(fn -> Plug.Telemetry.call(conn(:get, "/any"), opts) end) =~ "[info] GET /any" end test "invokes log level from Plug.Telemetry" do assert ExUnit.CaptureLog.capture_log(fn -> opts = Plug.Telemetry.init(event_prefix: [:phoenix, :endpoint], log: :error) Plug.Telemetry.call(conn(:get, "/"), opts) end) =~ "[error] GET /" end end end ================================================ FILE: test/phoenix/naming_test.exs ================================================ defmodule Phoenix.NamingTest do use ExUnit.Case, async: true alias Phoenix.Naming doctest Naming test "underscore/1 converts Strings to underscore" do assert Naming.underscore("FooBar") == "foo_bar" assert Naming.underscore("Foobar") == "foobar" assert Naming.underscore("APIWorld") == "api_world" assert Naming.underscore("ErlangVM") == "erlang_vm" assert Naming.underscore("API.V1.User") == "api/v1/user" assert Naming.underscore("") == "" assert Naming.underscore("FooBar1") == "foo_bar1" assert Naming.underscore("fooBar1") == "foo_bar1" end test "camelize/1 converts Strings to camel case" do assert Naming.camelize("foo_bar") == "FooBar" assert Naming.camelize("foo__bar") == "FooBar" assert Naming.camelize("foobar") == "Foobar" assert Naming.camelize("_foobar") == "Foobar" assert Naming.camelize("__foobar") == "Foobar" assert Naming.camelize("_FooBar") == "FooBar" assert Naming.camelize("foobar_") == "Foobar" assert Naming.camelize("foobar_1") == "Foobar1" assert Naming.camelize("") == "" assert Naming.camelize("_foo_bar") == "FooBar" assert Naming.camelize("foo_bar_1") == "FooBar1" end test "camelize/2 converts Strings to lower camel case" do assert Naming.camelize("foo_bar", :lower) == "fooBar" assert Naming.camelize("foo__bar", :lower) == "fooBar" assert Naming.camelize("foobar", :lower) == "foobar" assert Naming.camelize("_foobar", :lower) == "foobar" assert Naming.camelize("__foobar", :lower) == "foobar" assert Naming.camelize("_FooBar", :lower) == "fooBar" assert Naming.camelize("foobar_", :lower) == "foobar" assert Naming.camelize("foobar_1", :lower) == "foobar1" assert Naming.camelize("", :lower) == "" assert Naming.camelize("_foo_bar", :lower) == "fooBar" assert Naming.camelize("foo_bar_1", :lower) == "fooBar1" end end ================================================ FILE: test/phoenix/param_test.exs ================================================ defmodule Phoenix.ParamTest do use ExUnit.Case, async: true import Phoenix.Param test "to_param for integers" do assert to_param(1) == "1" end test "to_param for floats" do assert to_param(3.14) == "3.14" end test "to_param for binaries" do assert to_param("foo") == "foo" end test "to_param for atoms" do assert to_param(:foo) == "foo" assert to_param(true) == "true" assert to_param(false) == "false" assert_raise ArgumentError, fn -> to_param(nil) end end test "to_param for maps" do assert_raise ArgumentError, fn -> to_param(%{id: 1}) end end test "to_param for structs" do defmodule Foo do defstruct [:id] end assert to_param(struct(Foo, id: 1)) == "1" assert to_param(struct(Foo, id: "foo")) == "foo" after :code.purge(__MODULE__.Foo) :code.delete(__MODULE__.Foo) end test "to_param for derivable structs without id" do msg = ~r"cannot derive Phoenix.Param for struct Phoenix.ParamTest.Bar" assert_raise ArgumentError, msg, fn -> defmodule Bar do @derive Phoenix.Param defstruct [:uuid] end end defmodule Bar do @derive {Phoenix.Param, key: :uuid} defstruct [:uuid] end assert to_param(struct(Bar, uuid: 1)) == "1" assert to_param(struct(Bar, uuid: "foo")) == "foo" msg = ~r"cannot convert Phoenix.ParamTest.Bar to param, key :uuid contains a nil value" assert_raise ArgumentError, msg, fn -> to_param(struct(Bar, uuid: nil)) end after :code.purge(Module.concat(Phoenix.Param, __MODULE__.Bar)) :code.delete(Module.concat(Phoenix.Param, __MODULE__.Bar)) :code.purge(__MODULE__.Bar) :code.delete(__MODULE__.Bar) end end ================================================ FILE: test/phoenix/presence_test.exs ================================================ defmodule Phoenix.PresenceTest do use ExUnit.Case, async: true alias Phoenix.Socket.Broadcast defmodule DefaultPresence do use Phoenix.Presence, otp_app: :phoenix end defmodule MyPresence do use Phoenix.Presence, otp_app: :phoenix def fetch(_topic, entries) do for {key, %{metas: metas}} <- entries, into: %{} do {key, %{metas: metas, extra: "extra"}} end end end defmodule MetasPresence do use Phoenix.Presence, otp_app: :phoenix def init(state), do: {:ok, state} def handle_metas(topic, diff, presences, state) do Phoenix.PubSub.local_broadcast(PresPub, topic, %{diff: diff, presences: presences}) {:ok, state} end end defmodule MetasMissingInitPresence do use Phoenix.Presence, otp_app: :phoenix def init_presence do Phoenix.Presence.init({ __MODULE__, __MODULE__.TaskSupervisor, PresPub, Phoenix.Channel.Server }) end def handle_metas(_topic, _diff, _presences, _state) do raise ArgumentError, "should not be called due to missing init/1" end end defmodule CustomDispatcher do def dispatch(entries, from, message) do for {pid, _} <- entries, pid != from, do: send(pid, {:custom_dispatcher, message}) :ok end end defmodule CustomDispatcherPresence do use Phoenix.Presence, otp_app: :phoenix, dispatcher: CustomDispatcher end Application.put_env(:phoenix, MyPresence, pubsub_server: PresPub) Application.put_env(:phoenix, MetasPresence, pubsub_server: PresPub) Application.put_env(:phoenix, CustomDispatcherPresence, pubsub_server: PresPub) setup_all do start_supervised!({Phoenix.PubSub, name: PresPub, pool_size: 1}) start_supervised!(MyPresence) start_supervised!(MetasPresence) start_supervised!(CustomDispatcherPresence) {:ok, pubsub: PresPub} end setup config do {:ok, topic: to_string(config.test)} end test "defines child_spec/1" do assert DefaultPresence.child_spec([]) == %{ id: DefaultPresence, start: {Phoenix.Presence, :start_link, [ Phoenix.PresenceTest.DefaultPresence, Phoenix.PresenceTest.DefaultPresence.TaskSupervisor, [otp_app: :phoenix] ]}, type: :supervisor } end test "default fetch/2 returns pass-through data", config do presences = %{"u1" => %{metas: [%{name: "u1", phx_ref: "ref"}]}} assert DefaultPresence.fetch(config.topic, presences) == presences end test "list/1 lists presences from tracker", config do assert MyPresence.list(config.topic) == %{} assert MyPresence.list(%Phoenix.Socket{topic: config.topic}) == %{} assert {:ok, _} = MyPresence.track(self(), config.topic, "u1", %{name: "u1"}) assert %{"u1" => %{extra: "extra", metas: [%{name: "u1", phx_ref: _}]}} = MyPresence.list(config.topic) assert %{"u1" => %{extra: "extra", metas: [%{name: "u1", phx_ref: _}]}} = MyPresence.list(%Phoenix.Socket{topic: config.topic}) end test "list/1 returns keys as strings", config do assert {:ok, _} = MyPresence.track(self(), config.topic, 1, %{name: "u1"}) assert %{"1" => %{extra: "extra", metas: [%{name: "u1", phx_ref: _}]}} = MyPresence.list(config.topic) end test "get_by_key/2 returns metadata for key", config do pid2 = spawn(fn -> :timer.sleep(:infinity) end) pid3 = spawn(fn -> :timer.sleep(:infinity) end) assert MyPresence.get_by_key(config.topic, 1) == [] assert {:ok, _} = MyPresence.track(self(), config.topic, 1, %{name: "u1"}) assert {:ok, _} = MyPresence.track(pid2, config.topic, 1, %{name: "u1.2"}) assert {:ok, _} = MyPresence.track(pid3, config.topic, 2, %{name: "u1.2"}) assert %{extra: "extra", metas: [%{name: "u1", phx_ref: _}, %{name: "u1.2", phx_ref: _}]} = MyPresence.get_by_key(config.topic, 1) assert MyPresence.get_by_key(config.topic, "another_key") == [] assert MyPresence.get_by_key("another_topic", 2) == [] end test "handle_diff broadcasts events with default fetched data", %{topic: topic} = config do pid = spawn(fn -> :timer.sleep(:infinity) end) Phoenix.PubSub.subscribe(config.pubsub, topic) start_supervised!({DefaultPresence, pubsub_server: config.pubsub}) DefaultPresence.track(pid, topic, "u1", %{name: "u1"}) assert_receive %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{"u1" => %{metas: [%{name: "u1", phx_ref: u1_ref}]}}, leaves: %{} } } assert %{"u1" => %{metas: [%{name: "u1", phx_ref: ^u1_ref}]}} = DefaultPresence.list(topic) Process.exit(pid, :kill) assert_receive %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{}, leaves: %{"u1" => %{metas: [%{name: "u1", phx_ref: ^u1_ref}]}} } } assert DefaultPresence.list(topic) == %{} end test "handle_diff broadcasts events with custom fetched data", %{topic: topic} = config do pid = spawn(fn -> :timer.sleep(:infinity) end) Phoenix.PubSub.subscribe(config.pubsub, topic) MyPresence.track(pid, topic, "u1", %{name: "u1"}) assert_receive %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{"u1" => %{extra: "extra", metas: [%{name: "u1", phx_ref: u1_ref}]}}, leaves: %{} } } assert %{"u1" => %{extra: "extra", metas: [%{name: "u1", phx_ref: ^u1_ref}]}} = MyPresence.list(topic) Process.exit(pid, :kill) assert_receive %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{}, leaves: %{"u1" => %{extra: "extra", metas: [%{name: "u1", phx_ref: ^u1_ref}]}} } } assert MyPresence.list(topic) == %{} end test "handle_diff with custom dispatcher", %{topic: topic} = config do pid = spawn(fn -> :timer.sleep(:infinity) end) Phoenix.PubSub.subscribe(config.pubsub, topic) start_supervised!({DefaultPresence, pubsub_server: config.pubsub}) CustomDispatcherPresence.track(pid, topic, "u1", %{name: "u1"}) assert_receive {:custom_dispatcher, %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{"u1" => %{metas: [%{name: "u1", phx_ref: u1_ref}]}}, leaves: %{} } }} assert %{"u1" => %{metas: [%{name: "u1", phx_ref: ^u1_ref}]}} = CustomDispatcherPresence.list(topic) Process.exit(pid, :kill) assert_receive {:custom_dispatcher, %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{}, leaves: %{"u1" => %{metas: [%{name: "u1", phx_ref: ^u1_ref}]}} } }} assert CustomDispatcherPresence.list(topic) == %{} end test "untrack with pid", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, config.topic) MyPresence.track(self(), config.topic, "u1", %{}) MyPresence.track(self(), config.topic, "u2", %{}) assert %{ "u1" => %{extra: "extra", metas: [%{}]}, "u2" => %{extra: "extra", metas: [%{}]} } = MyPresence.list(config.topic) assert MyPresence.untrack(self(), config.topic, "u1") == :ok assert_receive %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{}, leaves: %{"u1" => %{metas: [%{}]}} } } assert %{"u2" => %{extra: "extra", metas: [%{}]}} = MyPresence.list(config.topic) assert map_size(MyPresence.list(config.topic)) == 1 end test "track and untrack with %Socket{}", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) socket = %Phoenix.Socket{topic: topic, channel_pid: self()} MyPresence.track(socket, "u1", %{}) assert %{"u1" => %{metas: [%{}]}} = MyPresence.list(topic) assert MyPresence.untrack(socket, "u1") == :ok assert_receive %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{}, leaves: %{"u1" => %{metas: [%{}]}} } } assert MyPresence.list(topic) == %{} end test "untrack with no tracked presence", config do assert MyPresence.untrack(self(), config.topic, "u1") == :ok end test "update sends join and leave diff", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) MyPresence.track(self(), topic, "u1", %{name: "u1"}) assert %{"u1" => %{metas: [%{name: "u1"}]}} = MyPresence.list(topic) assert {:ok, _} = MyPresence.update(self(), topic, "u1", %{name: "updated"}) assert_receive %Broadcast{ topic: ^topic, event: "presence_diff", payload: %{ joins: %{"u1" => %{metas: [%{name: "updated"}]}}, leaves: %{"u1" => %{metas: [%{name: "u1"}]}} } } assert %{"u1" => %{metas: [%{name: "updated"}]}} = MyPresence.list(topic) end test "update with no tracked presence" do assert MyPresence.update(self(), "topic", "u1", %{}) == {:error, :nopresence} end test "fetchers_pid" do assert is_list(MyPresence.fetchers_pids()) end describe "Presence behaviour when handle_metas is defined" do test "raises when missing init/1" do assert_raise ArgumentError, ~r|missing Phoenix.PresenceTest.MetasMissingInitPresence.init/1 callback for client state|, fn -> MetasMissingInitPresence.init_presence() end end test "async_merge/2 creates new topic and metas", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) MetasPresence.track(self(), topic, "u1", %{name: "u1"}) assert_receive %{ diff: %{ joins: %{"u1" => %{metas: [%{name: "u1"}]}}, leaves: %{} }, presences: presences } assert %{"u1" => [%{name: "u1", phx_ref: _ref}]} = presences end test "async_merge/2 adds new presences to existing topic", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) pid1 = spawn(fn -> :timer.sleep(:infinity) end) pid2 = spawn(fn -> :timer.sleep(:infinity) end) MetasPresence.track(pid1, topic, "u1", %{name: "u1"}) MetasPresence.track(pid2, topic, "u2", %{name: "u2"}) MetasPresence.track(self(), topic, "u3", %{name: "u3"}) assert_receive %{ diff: %{ joins: %{"u3" => %{metas: [%{name: "u3"}]}}, leaves: %{} }, presences: presences } assert %{ "u1" => [%{name: "u1", phx_ref: _u1_ref}], "u2" => [%{name: "u2", phx_ref: _u2_ref}], "u3" => [%{name: "u3", phx_ref: _u3_ref}] } = presences end test "async_merge/2 adds new metas to existing presence", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) pid1 = spawn(fn -> :timer.sleep(:infinity) end) pid2 = spawn(fn -> :timer.sleep(:infinity) end) MetasPresence.track(pid1, topic, "u1", %{name: "u1.1"}) MetasPresence.track(pid2, topic, "u1", %{name: "u1.2"}) MetasPresence.track(self(), topic, "u1", %{name: "u1.3"}) assert_receive %{ diff: %{ joins: %{"u1" => %{metas: [%{name: "u1.3"}]}}, leaves: %{} }, presences: presences } assert %{ "u1" => [ %{name: "u1.1", phx_ref: _u1_1_ref}, %{name: "u1.2", phx_ref: _u1_2_ref}, %{name: "u1.3", phx_ref: _u1_3_ref} ] } = presences end test "async_merge/2 removes topic if it doesn't have presences", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) pid1 = spawn(fn -> :timer.sleep(:infinity) end) pid2 = spawn(fn -> :timer.sleep(:infinity) end) MetasPresence.track(pid1, topic, "u1", %{name: "u1"}) MetasPresence.track(pid2, topic, "u2", %{name: "u2"}) MetasPresence.track(self(), topic, "u3", %{name: "u3"}) MetasPresence.untrack(pid1, topic, "u1") MetasPresence.untrack(pid2, topic, "u2") MetasPresence.untrack(self(), topic, "u3") assert_receive %{ diff: %{ joins: %{}, leaves: %{"u3" => %{metas: [%{name: "u3"}]}} }, presences: presences } assert presences == %{} end test "async_merge/2 removes presence info if it only has one meta", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) pid1 = spawn(fn -> :timer.sleep(:infinity) end) pid2 = spawn(fn -> :timer.sleep(:infinity) end) MetasPresence.track(pid1, topic, "u1", %{name: "u1"}) MetasPresence.track(pid2, topic, "u2", %{name: "u2"}) MetasPresence.track(self(), topic, "u3", %{name: "u3"}) MetasPresence.untrack(self(), topic, "u3") assert_receive %{ diff: %{ joins: %{}, leaves: %{"u3" => %{metas: [%{name: "u3"}]}} }, presences: presences } assert map_size(presences) == 2 assert %{ "u1" => [%{name: "u1", phx_ref: _u1_ref}], "u2" => [%{name: "u2", phx_ref: _u2_ref}] } = presences end test "async_merge/2 removes metas when a presence left", %{topic: topic} = config do Phoenix.PubSub.subscribe(config.pubsub, topic) pid1 = spawn(fn -> :timer.sleep(:infinity) end) pid2 = spawn(fn -> :timer.sleep(:infinity) end) MetasPresence.track(pid1, topic, "u1", %{name: "u1.1"}) MetasPresence.track(pid2, topic, "u1", %{name: "u1.2"}) MetasPresence.track(self(), topic, "u1", %{name: "u1.3"}) MetasPresence.untrack(self(), topic, "u1") assert_receive %{ diff: %{ joins: %{}, leaves: %{"u1" => %{metas: [%{name: "u1.3"}]}} }, presences: presences } assert %{"u1" => metas} = presences assert length(metas) == 2 assert [ %{name: "u1.1", phx_ref: _u1_1_ref}, %{name: "u1.2", phx_ref: _u1_2_ref} ] = metas end end end ================================================ FILE: test/phoenix/router/console_formatter_test.exs ================================================ for module <- [RouteFormatter.PageController, RouteFormatter.ImageController] do defmodule module do def init(opts), do: opts def call(conn, _opts), do: conn end end defmodule Phoenix.Router.ConsoleFormatterTest do use ExUnit.Case, async: true alias Phoenix.Router.ConsoleFormatter defmodule RouterTestSingleRoutes do use Phoenix.Router get "/", RouteFormatter.PageController, :index, as: :page post "/images", RouteFormatter.ImageController, :upload, as: :upload_image delete "/images", RouteFormatter.ImageController, :delete, as: :remove_image end def __sockets__, do: [] defmodule FormatterEndpoint do use Phoenix.Endpoint, otp_app: :phoenix socket "/socket", TestSocket, websocket: true end test "format multiple routes" do assert draw(RouterTestSingleRoutes) == """ page_path GET / RouteFormatter.PageController :index upload_image_path POST /images RouteFormatter.ImageController :upload remove_image_path DELETE /images RouteFormatter.ImageController :delete """ end defmodule RouterTestResources do use Phoenix.Router resources "/images", RouteFormatter.ImageController end test "format resource routes" do assert draw(RouterTestResources) == """ image_path GET /images RouteFormatter.ImageController :index image_path GET /images/:id/edit RouteFormatter.ImageController :edit image_path GET /images/new RouteFormatter.ImageController :new image_path GET /images/:id RouteFormatter.ImageController :show image_path POST /images RouteFormatter.ImageController :create image_path PATCH /images/:id RouteFormatter.ImageController :update PUT /images/:id RouteFormatter.ImageController :update image_path DELETE /images/:id RouteFormatter.ImageController :delete """ end defmodule RouterTestResource do use Phoenix.Router resources "/image", RouteFormatter.ImageController, singleton: true forward "/admin", RouteFormatter.PageController, [], as: :admin forward "/f1", RouteFormatter.ImageController end test "format single resource routes" do assert draw(RouterTestResource) == """ image_path GET /image/edit RouteFormatter.ImageController :edit image_path GET /image/new RouteFormatter.ImageController :new image_path GET /image RouteFormatter.ImageController :show image_path POST /image RouteFormatter.ImageController :create image_path PATCH /image RouteFormatter.ImageController :update PUT /image RouteFormatter.ImageController :update image_path DELETE /image RouteFormatter.ImageController :delete * /admin RouteFormatter.PageController [] * /f1 RouteFormatter.ImageController [] """ end describe "endpoint sockets" do test "format with sockets" do assert draw(RouterTestSingleRoutes, FormatterEndpoint) == """ page_path GET / RouteFormatter.PageController :index upload_image_path POST /images RouteFormatter.ImageController :upload remove_image_path DELETE /images RouteFormatter.ImageController :delete WS /socket/websocket TestSocket GET /socket/longpoll TestSocket POST /socket/longpoll TestSocket """ end test "format without sockets" do assert draw(RouterTestSingleRoutes, __MODULE__) == """ page_path GET / RouteFormatter.PageController :index upload_image_path POST /images RouteFormatter.ImageController :upload remove_image_path DELETE /images RouteFormatter.ImageController :delete """ end end defmodule HelpersFalseRouter do use Phoenix.Router, helpers: false resources "/image", RouteFormatter.ImageController end test "helpers: false" do assert draw(HelpersFalseRouter) == """ GET /image RouteFormatter.ImageController :index GET /image/:id/edit RouteFormatter.ImageController :edit GET /image/new RouteFormatter.ImageController :new GET /image/:id RouteFormatter.ImageController :show POST /image RouteFormatter.ImageController :create PATCH /image/:id RouteFormatter.ImageController :update PUT /image/:id RouteFormatter.ImageController :update DELETE /image/:id RouteFormatter.ImageController :delete """ assert draw(HelpersFalseRouter, FormatterEndpoint) == """ GET /image RouteFormatter.ImageController :index GET /image/:id/edit RouteFormatter.ImageController :edit GET /image/new RouteFormatter.ImageController :new GET /image/:id RouteFormatter.ImageController :show POST /image RouteFormatter.ImageController :create PATCH /image/:id RouteFormatter.ImageController :update PUT /image/:id RouteFormatter.ImageController :update DELETE /image/:id RouteFormatter.ImageController :delete WS /socket/websocket TestSocket GET /socket/longpoll TestSocket POST /socket/longpoll TestSocket """ end defp draw(router, endpoint \\ nil) do ConsoleFormatter.format(router, endpoint) end end ================================================ FILE: test/phoenix/router/forward_test.exs ================================================ defmodule Phoenix.Router.HealthController do use Phoenix.Controller, formats: [] def health(conn, _params), do: text(conn, "health") end defmodule Phoenix.Router.ForwardTest do use ExUnit.Case, async: true use RouterHelper defmodule Controller do use Phoenix.Controller, formats: [] plug :assign_fwd_script def index(conn, _params), do: text(conn, "admin index") def stats(conn, _params), do: text(conn, "stats") def api_users(conn, _params), do: text(conn, "api users") def api_root(conn, _params), do: text(conn, "api root") defp assign_fwd_script(conn, _), do: assign(conn, :fwd_script, conn.script_name) end defmodule ApiRouter do use Phoenix.Router get "/", Controller, :api_root get "/users", Controller, :api_users scope "/health", Phoenix.Router do forward "/", HealthController, :health end end defmodule AdminDashboard do use Phoenix.Router get "/", Controller, :index, as: :page get "/stats", Controller, :stats, as: :page forward "/api-admin", ApiRouter end defmodule InitPlug do def init(_), do: %{non: :literal} def call(conn, %{non: :literal} = opts), do: assign(conn, :opts, opts) end defmodule AssignOptsPlug do def init(opts), do: opts def call(conn, opts), do: assign(conn, :opts, opts) end defmodule Router do use Phoenix.Router scope "/" do get "/stats", Controller, :stats forward "/admin", AdminDashboard forward "/init", InitPlug forward "/assign/opts", AssignOptsPlug, %{foo: "bar"} end end setup do Logger.put_process_level(self(), :none) :ok end test "forwards path to plug" do conn = call(Router, :get, "/admin") assert conn.script_name == [] assert conn.assigns[:fwd_script] == ["admin"] assert conn.status == 200 assert conn.resp_body == "admin index" end test "forwards any request starting with forward path" do conn = call(Router, :get, "/admin/stats") assert conn.script_name == [] assert conn.assigns[:fwd_script] == ["admin"] assert conn.status == 200 assert conn.resp_body == "stats" end test "forward with dynamic segments raises" do router = quote do defmodule BadRouter do use Phoenix.Router forward "/api/:version", ApiRouter end end assert_raise ArgumentError, ~r{dynamic segment "/api/:version" not allowed}, fn -> Code.eval_quoted(router) end end test "accumulates script names" do conn = call(Router, :get, "/admin") assert conn.private[Router] == [] assert conn.private[AdminDashboard] == ["admin"] end test "helpers cascade script name across forwards based on main router" do import AdminDashboard.Helpers assert page_path(%Plug.Conn{}, :stats) == "/stats" conn = call(Router, :get, "/stats") assert page_path(conn, :stats) == "/admin/stats" conn = call(Router, :get, "/stats", _params = nil, ["phx"]) assert page_path(conn, :stats) == "/phx/admin/stats" conn = call(Router, :get, "/admin/stats") assert page_path(conn, :stats) == "/admin/stats" conn = call(Router, :get, "/admin/stats", _params = nil, ["phx"]) assert page_path(conn, :stats) == "/phx/admin/stats" end test "forward can handle plugs with non-literal init returns" do assert call(Router, :get, "/init").assigns.opts == %{non: :literal} end test "forward can handle plugs with custom options" do assert call(Router, :get, "/assign/opts").assigns.opts == %{foo: "bar"} end test "forward with scoped alias" do conn = call(ApiRouter, :get, "/health") assert conn.resp_body == "health" assert conn.private[ApiRouter] == [] end test "forwards raises if using the plug to arguments" do error_message = ~r/expect a module/ assert_raise(ArgumentError, error_message, fn -> defmodule BrokenRouter do use Phoenix.Router scope "/" do forward "/health", to: HealthController end end end) end end ================================================ FILE: test/phoenix/router/helpers_test.exs ================================================ modules = [ PostController, ChatController, UserController, CommentController, FileController, ProductController, Admin.MessageController, SubPlug ] for module <- modules do defmodule module do def init(opts), do: opts def call(conn, _opts), do: conn end end defmodule Phoenix.Router.HelpersTest do use ExUnit.Case, async: true use RouterHelper defmodule Router do use Phoenix.Router get "/posts/top", PostController, :top, as: :top get "/posts/bottom/:order/:count", PostController, :bottom, as: :bottom get "/posts/:id", PostController, :show get "/posts/file/*file", PostController, :file get "/posts/skip", PostController, :skip, as: nil resources "/users", UserController do resources "/comments", CommentController do resources "/files", FileController end end scope "/", host: "users." do post "/host_users/:id/info", UserController, :create end resources "/files", FileController resources "/account", UserController, as: :account, singleton: true do resources "/page", PostController, as: :page, only: [:show], singleton: true end scope "/admin", alias: Admin do resources "/messages", MessageController end scope "/admin/new", alias: Admin, as: "admin" do resources "/messages", MessageController scope "/unscoped", as: false do resources "/messages", MessageController, as: :my_admin_message end end get "/", PostController, :root, as: :page get "/products/:id", ProductController, :show get "/products", ProductController, :show get "/products/:id/:sort", ProductController, :show get "/products/:id/:sort/:page", ProductController, :show get "/mfa_path", SubPlug, func: {M, :f, [10]} end # Emulate regular endpoint functions defmodule Endpoint do def url do "https://example.com" end def static_url do "https://static.example.com" end def path(path) do path end def static_path(path) do path end def static_integrity(_path), do: nil end alias Router.Helpers test "defines a __helpers__ function" do assert Router.__helpers__() == Router.Helpers end test "root helper" do conn = conn(:get, "/") |> put_private(:phoenix_endpoint, Endpoint) assert Helpers.page_path(conn, :root) == "/" assert Helpers.page_path(Endpoint, :root) == "/" end test "url helper with query strings" do assert Helpers.post_path(Endpoint, :show, 5, id: 3) == "/posts/5" assert Helpers.post_path(Endpoint, :show, 5, foo: "bar") == "/posts/5?foo=bar" assert Helpers.post_path(Endpoint, :show, 5, foo: :bar) == "/posts/5?foo=bar" assert Helpers.post_path(Endpoint, :show, 5, foo: true) == "/posts/5?foo=true" assert Helpers.post_path(Endpoint, :show, 5, foo: false) == "/posts/5?foo=false" assert Helpers.post_path(Endpoint, :show, 5, foo: nil) == "/posts/5?foo=" assert Helpers.post_path(Endpoint, :show, 5, foo: ~w(bar baz)) == "/posts/5?foo[]=bar&foo[]=baz" assert Helpers.post_path(Endpoint, :show, 5, foo: %{id: 5}) == "/posts/5?foo[id]=5" assert Helpers.post_path(Endpoint, :show, 5, foo: %{__struct__: Foo, id: 5}) == "/posts/5?foo=5" end test "url helper with param protocol" do assert Helpers.post_path(Endpoint, :show, %{__struct__: Foo, id: 5}) == "/posts/5" assert_raise ArgumentError, fn -> Helpers.post_path(Endpoint, :show, nil) end end test "url helper shows an error if an id is accidentally passed" do error_suggestion = ~r/bottom_path\(conn, :bottom, order, count, page: 5, per_page: 10\)/ assert_raise ArgumentError, error_suggestion, fn -> Helpers.bottom_path(Endpoint, :bottom, :asc, 8, {:not, :enumerable}) end error_suggestion = ~r/top_path\(conn, :top, page: 5, per_page: 10\)/ assert_raise ArgumentError, error_suggestion, fn -> Helpers.top_path(Endpoint, :top, "invalid") end end test "top-level named route" do assert Helpers.post_path(Endpoint, :show, 5) == "/posts/5" assert Helpers.post_path(Endpoint, :show, 5, []) == "/posts/5" assert Helpers.post_path(Endpoint, :show, 5, id: 5) == "/posts/5" assert Helpers.post_path(Endpoint, :show, 5, %{"id" => 5}) == "/posts/5" assert Helpers.post_path(Endpoint, :show, "foo") == "/posts/foo" assert Helpers.post_path(Endpoint, :show, "foo bar") == "/posts/foo%20bar" assert Helpers.post_path(Endpoint, :file, ["foo", "bar/baz"]) == "/posts/file/foo/bar%2Fbaz" assert Helpers.post_path(Endpoint, :file, ["foo", "bar"], []) == "/posts/file/foo/bar" assert Helpers.post_path(Endpoint, :file, ["foo", "bar baz"], []) == "/posts/file/foo/bar%20baz" assert Helpers.top_path(Endpoint, :top) == "/posts/top" assert Helpers.top_path(Endpoint, :top, id: 5) == "/posts/top?id=5" assert Helpers.top_path(Endpoint, :top, %{"id" => 5}) == "/posts/top?id=5" assert Helpers.top_path(Endpoint, :top, %{"id" => "foo"}) == "/posts/top?id=foo" assert Helpers.top_path(Endpoint, :top, %{"id" => "foo bar"}) == "/posts/top?id=foo+bar" error_message = fn helper, arity -> """ no action :skip for #{inspect(Helpers)}.#{helper}/#{arity}. The following actions/clauses are supported: #{helper}(conn_or_endpoint, :file, file, params \\\\ []) #{helper}(conn_or_endpoint, :show, id, params \\\\ []) """ |> String.trim() end assert_raise ArgumentError, error_message.("post_path", 3), fn -> Helpers.post_path(Endpoint, :skip, 5) end assert_raise ArgumentError, error_message.("post_url", 3), fn -> Helpers.post_url(Endpoint, :skip, 5) end assert_raise ArgumentError, error_message.("post_path", 4), fn -> Helpers.post_path(Endpoint, :skip, 5, foo: "bar", other: "param") end assert_raise ArgumentError, error_message.("post_url", 4), fn -> Helpers.post_url(Endpoint, :skip, 5, foo: "bar", other: "param") end end test "top-level named routes with complex ids" do assert Helpers.post_path(Endpoint, :show, "==d--+") == "/posts/%3D%3Dd--%2B" assert Helpers.post_path(Endpoint, :show, "==d--+", []) == "/posts/%3D%3Dd--%2B" assert Helpers.top_path(Endpoint, :top, id: "==d--+") == "/posts/top?id=%3D%3Dd--%2B" assert Helpers.post_path(Endpoint, :file, ["==d--+", ":O.jpg"]) == "/posts/file/%3D%3Dd--%2B/%3AO.jpg" assert Helpers.post_path(Endpoint, :file, ["==d--+", ":O.jpg"], []) == "/posts/file/%3D%3Dd--%2B/%3AO.jpg" assert Helpers.post_path(Endpoint, :file, ["==d--+", ":O.jpg"], xx: "/=+/") == "/posts/file/%3D%3Dd--%2B/%3AO.jpg?xx=%2F%3D%2B%2F" end test "resources generates named routes for :index, :edit, :show, :new" do assert Helpers.user_path(Endpoint, :index, []) == "/users" assert Helpers.user_path(Endpoint, :index) == "/users" assert Helpers.user_path(Endpoint, :edit, 123, []) == "/users/123/edit" assert Helpers.user_path(Endpoint, :edit, 123) == "/users/123/edit" assert Helpers.user_path(Endpoint, :show, 123, []) == "/users/123" assert Helpers.user_path(Endpoint, :show, 123) == "/users/123" assert Helpers.user_path(Endpoint, :new, []) == "/users/new" assert Helpers.user_path(Endpoint, :new) == "/users/new" end test "resources generated named routes with complex ids" do assert Helpers.user_path(Endpoint, :edit, "1a+/31d", []) == "/users/1a%2B%2F31d/edit" assert Helpers.user_path(Endpoint, :edit, "1a+/31d") == "/users/1a%2B%2F31d/edit" assert Helpers.user_path(Endpoint, :show, "1a+/31d", []) == "/users/1a%2B%2F31d" assert Helpers.user_path(Endpoint, :show, "1a+/31d") == "/users/1a%2B%2F31d" assert Helpers.message_path(Endpoint, :update, "8=/=d", []) == "/admin/messages/8%3D%2F%3Dd" assert Helpers.message_path(Endpoint, :update, "8=/=d") == "/admin/messages/8%3D%2F%3Dd" assert Helpers.message_path(Endpoint, :delete, "8=/=d", []) == "/admin/messages/8%3D%2F%3Dd" assert Helpers.message_path(Endpoint, :delete, "8=/=d") == "/admin/messages/8%3D%2F%3Dd" assert Helpers.user_path(Endpoint, :show, "1a+/31d", dog: "8d=") == "/users/1a%2B%2F31d?dog=8d%3D" assert Helpers.user_path(Endpoint, :index, cat: "=8+/&") == "/users?cat=%3D8%2B%2F%26" end test "resources generates named routes for :create, :update, :delete" do assert Helpers.message_path(Endpoint, :create, []) == "/admin/messages" assert Helpers.message_path(Endpoint, :create) == "/admin/messages" assert Helpers.message_path(Endpoint, :update, 1, []) == "/admin/messages/1" assert Helpers.message_path(Endpoint, :update, 1) == "/admin/messages/1" assert Helpers.message_path(Endpoint, :delete, 1, []) == "/admin/messages/1" assert Helpers.message_path(Endpoint, :delete, 1) == "/admin/messages/1" end test "1-Level nested resources generates nested named routes for :index, :edit, :show, :new" do assert Helpers.user_comment_path(Endpoint, :index, 99, []) == "/users/99/comments" assert Helpers.user_comment_path(Endpoint, :index, 99) == "/users/99/comments" assert Helpers.user_comment_path(Endpoint, :edit, 88, 2, []) == "/users/88/comments/2/edit" assert Helpers.user_comment_path(Endpoint, :edit, 88, 2) == "/users/88/comments/2/edit" assert Helpers.user_comment_path(Endpoint, :show, 123, 2, []) == "/users/123/comments/2" assert Helpers.user_comment_path(Endpoint, :show, 123, 2) == "/users/123/comments/2" assert Helpers.user_comment_path(Endpoint, :new, 88, []) == "/users/88/comments/new" assert Helpers.user_comment_path(Endpoint, :new, 88) == "/users/88/comments/new" assert_raise ArgumentError, ~r/no action :skip/, fn -> Helpers.user_comment_file_path(Endpoint, :skip, 123, 456) end assert_raise ArgumentError, ~r/no action :skip/, fn -> Helpers.user_comment_file_path(Endpoint, :skip, 123, 456, foo: "bar") end assert_raise ArgumentError, ~r/no function clause for Phoenix.Router.HelpersTest.Router.Helpers.user_comment_path\/3 and action :show/, fn -> Helpers.user_comment_path(Endpoint, :show, 123) end end test "multi-level nested resources generated named routes with complex ids" do assert Helpers.user_comment_path(Endpoint, :index, "f4/d+~=", []) == "/users/f4%2Fd%2B~%3D/comments" assert Helpers.user_comment_path(Endpoint, :index, "f4/d+~=") == "/users/f4%2Fd%2B~%3D/comments" assert Helpers.user_comment_path(Endpoint, :edit, "f4/d+~=", "x-+=/", []) == "/users/f4%2Fd%2B~%3D/comments/x-%2B%3D%2F/edit" assert Helpers.user_comment_path(Endpoint, :edit, "f4/d+~=", "x-+=/") == "/users/f4%2Fd%2B~%3D/comments/x-%2B%3D%2F/edit" assert Helpers.user_comment_path(Endpoint, :show, "f4/d+~=", "x-+=/", []) == "/users/f4%2Fd%2B~%3D/comments/x-%2B%3D%2F" assert Helpers.user_comment_path(Endpoint, :show, "f4/d+~=", "x-+=/") == "/users/f4%2Fd%2B~%3D/comments/x-%2B%3D%2F" assert Helpers.user_comment_path(Endpoint, :new, "/==/", []) == "/users/%2F%3D%3D%2F/comments/new" assert Helpers.user_comment_path(Endpoint, :new, "/==/") == "/users/%2F%3D%3D%2F/comments/new" assert Helpers.user_comment_file_path(Endpoint, :show, "f4/d+~=", "/==/", "x-+=/", []) == "/users/f4%2Fd%2B~%3D/comments/%2F%3D%3D%2F/files/x-%2B%3D%2F" assert Helpers.user_comment_file_path(Endpoint, :show, "f4/d+~=", "/==/", "x-+=/") == "/users/f4%2Fd%2B~%3D/comments/%2F%3D%3D%2F/files/x-%2B%3D%2F" end test "2-Level nested resources generates nested named routes for :index, :edit, :show, :new" do assert Helpers.user_comment_file_path(Endpoint, :index, 99, 1, []) == "/users/99/comments/1/files" assert Helpers.user_comment_file_path(Endpoint, :index, 99, 1) == "/users/99/comments/1/files" assert Helpers.user_comment_file_path(Endpoint, :edit, 88, 1, 2, []) == "/users/88/comments/1/files/2/edit" assert Helpers.user_comment_file_path(Endpoint, :edit, 88, 1, 2) == "/users/88/comments/1/files/2/edit" assert Helpers.user_comment_file_path(Endpoint, :show, 123, 1, 2, []) == "/users/123/comments/1/files/2" assert Helpers.user_comment_file_path(Endpoint, :show, 123, 1, 2) == "/users/123/comments/1/files/2" assert Helpers.user_comment_file_path(Endpoint, :new, 88, 1, []) == "/users/88/comments/1/files/new" assert Helpers.user_comment_file_path(Endpoint, :new, 88, 1) == "/users/88/comments/1/files/new" end test "resources without block generates named routes for :index, :edit, :show, :new" do assert Helpers.file_path(Endpoint, :index, []) == "/files" assert Helpers.file_path(Endpoint, :index) == "/files" assert Helpers.file_path(Endpoint, :edit, 123, []) == "/files/123/edit" assert Helpers.file_path(Endpoint, :edit, 123) == "/files/123/edit" assert Helpers.file_path(Endpoint, :show, 123, []) == "/files/123" assert Helpers.file_path(Endpoint, :show, 123) == "/files/123" assert Helpers.file_path(Endpoint, :new, []) == "/files/new" assert Helpers.file_path(Endpoint, :new) == "/files/new" end test "resource generates named routes for :show, :edit, :new, :update, :delete" do assert Helpers.account_path(Endpoint, :show, []) == "/account" assert Helpers.account_path(Endpoint, :show) == "/account" assert Helpers.account_path(Endpoint, :edit, []) == "/account/edit" assert Helpers.account_path(Endpoint, :edit) == "/account/edit" assert Helpers.account_path(Endpoint, :new, []) == "/account/new" assert Helpers.account_path(Endpoint, :new) == "/account/new" assert Helpers.account_path(Endpoint, :update, []) == "/account" assert Helpers.account_path(Endpoint, :update) == "/account" assert Helpers.account_path(Endpoint, :delete, []) == "/account" assert Helpers.account_path(Endpoint, :delete) == "/account" end test "2-Level nested resource generates nested named routes for :show" do assert Helpers.account_page_path(Endpoint, :show, []) == "/account/page" assert Helpers.account_page_path(Endpoint, :show) == "/account/page" end test "scoped route helpers generated named routes with :path, and :alias options" do assert Helpers.message_path(Endpoint, :index, []) == "/admin/messages" assert Helpers.message_path(Endpoint, :index) == "/admin/messages" assert Helpers.message_path(Endpoint, :show, 1, []) == "/admin/messages/1" assert Helpers.message_path(Endpoint, :show, 1) == "/admin/messages/1" end test "scoped route helpers generated named routes with :path, :alias, and :helper options" do assert Helpers.admin_message_path(Endpoint, :index, []) == "/admin/new/messages" assert Helpers.admin_message_path(Endpoint, :index) == "/admin/new/messages" assert Helpers.admin_message_path(Endpoint, :show, 1, []) == "/admin/new/messages/1" assert Helpers.admin_message_path(Endpoint, :show, 1) == "/admin/new/messages/1" end test "scoped route helpers generated unscoped :as options" do assert Helpers.my_admin_message_path(Endpoint, :index, []) == "/admin/new/unscoped/messages" assert Helpers.my_admin_message_path(Endpoint, :index) == "/admin/new/unscoped/messages" assert Helpers.my_admin_message_path(Endpoint, :show, 1, []) == "/admin/new/unscoped/messages/1" assert Helpers.my_admin_message_path(Endpoint, :show, 1) == "/admin/new/unscoped/messages/1" end test "can pass an {m, f, a} tuple as a plug argument" do assert Helpers.sub_plug_path(Endpoint, func: {M, :f, [10]}) == "/mfa_path" end ## Others defp conn_with_endpoint do conn(:get, "/") |> put_private(:phoenix_endpoint, Endpoint) end defp socket_with_endpoint do %Phoenix.Socket{endpoint: Endpoint} end defp uri do %URI{scheme: "https", host: "example.com", port: 443} end test "helpers module generates a static_path helper" do assert Helpers.static_path(Endpoint, "/images/foo.png") == "/images/foo.png" assert Helpers.static_path(conn_with_endpoint(), "/images/foo.png") == "/images/foo.png" assert Helpers.static_path(socket_with_endpoint(), "/images/foo.png") == "/images/foo.png" end test "helpers module generates a static_url helper" do url = "https://static.example.com/images/foo.png" assert Helpers.static_url(Endpoint, "/images/foo.png") == url assert Helpers.static_url(conn_with_endpoint(), "/images/foo.png") == url assert Helpers.static_url(socket_with_endpoint(), "/images/foo.png") == url end test "helpers module generates a url helper" do assert Helpers.url(Endpoint) == "https://example.com" assert Helpers.url(conn_with_endpoint()) == "https://example.com" assert Helpers.url(socket_with_endpoint()) == "https://example.com" assert Helpers.url(uri()) == "https://example.com" end test "helpers module generates a path helper" do assert Helpers.path(Endpoint, "/") == "/" assert Helpers.path(conn_with_endpoint(), "/") == "/" assert Helpers.path(socket_with_endpoint(), "/") == "/" assert Helpers.path(uri(), "/") == "/" end test "helpers module generates a static_integrity helper" do assert is_nil(Helpers.static_integrity(Endpoint, "/images/foo.png")) assert is_nil(Helpers.static_integrity(conn_with_endpoint(), "/images/foo.png")) assert is_nil(Helpers.static_integrity(socket_with_endpoint(), "/images/foo.png")) end test "helpers module generates named routes url helpers" do url = "https://example.com/admin/new/messages/1" assert Helpers.admin_message_url(Endpoint, :show, 1) == url assert Helpers.admin_message_url(Endpoint, :show, 1, []) == url assert Helpers.admin_message_url(conn_with_endpoint(), :show, 1) == url assert Helpers.admin_message_url(conn_with_endpoint(), :show, 1, []) == url assert Helpers.admin_message_url(socket_with_endpoint(), :show, 1) == url assert Helpers.admin_message_url(socket_with_endpoint(), :show, 1, []) == url assert Helpers.admin_message_url(uri(), :show, 1) == url assert Helpers.admin_message_url(uri(), :show, 1, []) == url end test "helpers properly encode named and query string params" do assert Router.Helpers.post_path(Endpoint, :show, "my path", foo: "my param") == "/posts/my%20path?foo=my+param" end test "duplicate helpers with unique arities" do assert Helpers.product_path(Endpoint, :show) == "/products" assert Helpers.product_path(Endpoint, :show, foo: "bar") == "/products?foo=bar" assert Helpers.product_path(Endpoint, :show, 123) == "/products/123" assert Helpers.product_path(Endpoint, :show, 123, foo: "bar") == "/products/123?foo=bar" assert Helpers.product_path(Endpoint, :show, 123, "asc") == "/products/123/asc" assert Helpers.product_path(Endpoint, :show, 123, "asc", foo: "bar") == "/products/123/asc?foo=bar" assert Helpers.product_path(Endpoint, :show, 123, "asc", 1) == "/products/123/asc/1" assert Helpers.product_path(Endpoint, :show, 123, "asc", 1, foo: "bar") == "/products/123/asc/1?foo=bar" end ## Script name defmodule ScriptName do def url do "https://example.com" end def static_url do "https://static.example.com" end def path(path) do "/api" <> path end def static_path(path) do "/api" <> path end end def conn_with_script_name(script_name \\ ~w(api)) do conn = conn(:get, "/") |> put_private(:phoenix_endpoint, ScriptName) put_in(conn.script_name, script_name) end defp uri_with_script_name do %URI{scheme: "https", host: "example.com", port: 123, path: "/api"} end test "paths use script name" do assert Helpers.page_path(ScriptName, :root) == "/api/" assert Helpers.page_path(conn_with_script_name(), :root) == "/api/" assert Helpers.page_path(uri_with_script_name(), :root) == "/api/" assert Helpers.post_path(ScriptName, :show, 5) == "/api/posts/5" assert Helpers.post_path(conn_with_script_name(), :show, 5) == "/api/posts/5" assert Helpers.post_path(uri_with_script_name(), :show, 5) == "/api/posts/5" end test "urls use script name" do assert Helpers.page_url(ScriptName, :root) == "https://example.com/api/" assert Helpers.page_url(conn_with_script_name(~w(foo)), :root) == "https://example.com/foo/" assert Helpers.page_url(uri_with_script_name(), :root) == "https://example.com:123/api/" assert Helpers.post_url(ScriptName, :show, 5) == "https://example.com/api/posts/5" assert Helpers.post_url(conn_with_script_name(), :show, 5) == "https://example.com/api/posts/5" assert Helpers.post_url(conn_with_script_name(~w(foo)), :show, 5) == "https://example.com/foo/posts/5" assert Helpers.post_url(uri_with_script_name(), :show, 5) == "https://example.com:123/api/posts/5" end test "static use endpoint script name only" do assert Helpers.static_path(conn_with_script_name(~w(foo)), "/images/foo.png") == "/api/images/foo.png" assert Helpers.static_url(conn_with_script_name(~w(foo)), "/images/foo.png") == "https://static.example.com/api/images/foo.png" end ## Dynamics test "phoenix_router_url with string takes precedence over endpoint" do url = "https://phoenixframework.org" conn = Phoenix.Controller.put_router_url(conn_with_endpoint(), url) assert Helpers.url(conn) == url assert Helpers.admin_message_url(conn, :show, 1) == url <> "/admin/new/messages/1" end test "phoenix_router_url with URI takes precedence over endpoint" do uri = %URI{scheme: "https", host: "phoenixframework.org", port: 123, path: "/path"} conn = Phoenix.Controller.put_router_url(conn_with_endpoint(), uri) assert Helpers.url(conn) == "https://phoenixframework.org:123/path" assert Helpers.admin_message_url(conn, :show, 1) == "https://phoenixframework.org:123/path/admin/new/messages/1" end test "phoenix_static_url with string takes precedence over endpoint" do url = "https://phoenixframework.org" conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), url) assert Helpers.static_url(conn, "/images/foo.png") == url <> "/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), url) assert Helpers.static_url(conn, "/images/foo.png") == url <> "/images/foo.png" end test "phoenix_static_url set to string with path results in static url with that path" do url = "https://phoenixframework.org/path" conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), url) assert Helpers.static_url(conn, "/images/foo.png") == url <> "/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), url) assert Helpers.static_url(conn, "/images/foo.png") == url <> "/images/foo.png" end test "phoenix_static_url with URI takes precedence over endpoint" do uri = %URI{scheme: "https", host: "phoenixframework.org", port: 123} conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), uri) assert Helpers.static_url(conn, "/images/foo.png") == "https://phoenixframework.org:123/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), uri) assert Helpers.static_url(conn, "/images/foo.png") == "https://phoenixframework.org:123/images/foo.png" end test "phoenix_static_url set to URI with path results in static url with that path" do uri = %URI{scheme: "https", host: "phoenixframework.org", port: 123, path: "/path"} conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), uri) assert Helpers.static_url(conn, "/images/foo.png") == "https://phoenixframework.org:123/path/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), uri) assert Helpers.static_url(conn, "/images/foo.png") == "https://phoenixframework.org:123/path/images/foo.png" end describe "helpers: false" do defmodule NoHelpersRouter do use Phoenix.Router, helpers: false get "/", PostController, :home end test "__helpers__ return nil" do assert NoHelpersRouter.__helpers__() == nil end test "test not generate Helpers module" do refute Code.ensure_loaded?(NoHelpersRouter.Helpers) end end end ================================================ FILE: test/phoenix/router/pipeline_test.exs ================================================ defmodule Phoenix.Router.PipelineTest.SampleController do use Phoenix.Controller, formats: [] def index(conn, _params), do: text(conn, "index") def crash(_conn, _params), do: raise("crash!") def noop_plug(conn, _opts), do: conn end alias Phoenix.Router.PipelineTest.SampleController defmodule Phoenix.Router.PipelineTest.Router do use Phoenix.Router # This should work even if the import comes # after the Phoenix.Router definition import SampleController, only: [noop_plug: 2] pipeline :browser do plug :put_assign, "browser" end pipeline :api do plug :put_assign, "api" end pipeline :params do plug :put_params end pipeline :halt do plug :stop end pipeline :halt_again do plug :stop end get "/root", SampleController, :index put "/root/:id", SampleController, :index get "/route_that_crashes", SampleController, :crash scope "/browser" do pipe_through :browser get "/root", SampleController, :index scope "/api" do pipe_through :api get "/root", SampleController, :index end scope "/:id" do pipe_through :params get "/", SampleController, :index end end scope "/browser-api" do pipe_through [:browser, :api] get "/root", SampleController, :index end scope "/stop" do pipe_through [:noop_plug, :halt, :halt_again] get "/", SampleController, :index end defp stop(conn, _) do conn |> send_resp(200, "stop") |> halt end defp put_assign(conn, value) do assign(conn, :stack, [value | conn.assigns[:stack] || []]) end defp put_params(conn, _) do assign(conn, :params, conn.params) end end alias Phoenix.Router.PipelineTest.Router defmodule Phoenix.Router.PipelineTest do use ExUnit.Case, async: true use RouterHelper setup do Logger.put_process_level(self(), :none) :ok end test "does not invoke pipelines at root" do conn = call(Router, :get, "/root") assert conn.assigns[:stack] == nil end test "invokes pipelines per scope" do conn = call(Router, :get, "/browser/root") assert conn.assigns[:stack] == ["browser"] end test "invokes pipelines in a nested scope" do conn = call(Router, :get, "/browser/api/root") assert conn.assigns[:stack] == ["api", "browser"] end test "invokes multiple pipelines" do conn = call(Router, :get, "/browser-api/root") assert conn.assigns[:stack] == ["api", "browser"] end test "halts on pipeline multiple pipelines" do conn = call(Router, :get, "/stop") assert conn.halted assert conn.status == 200 assert conn.resp_body == "stop" end test "wraps failures on call" do assert_raise Plug.Conn.WrapperError, fn -> call(Router, :get, "/route_that_crashes") end end test "merge parameters before invoking pipelines" do conn = call(Router, :get, "/browser/hello") assert conn.assigns[:params] == %{"id" => "hello"} end test "duplicate pipe_through's raises" do assert_raise ArgumentError, ~r{duplicate pipe_through for :browser}, fn -> defmodule DupPipeThroughRouter do use Phoenix.Router, otp_app: :phoenix pipeline :browser do end scope "/" do pipe_through [:browser, :auth] pipe_through [:browser] end end end assert_raise ArgumentError, ~r{duplicate pipe_through for :browser}, fn -> defmodule DupScopedPipeThroughRouter do use Phoenix.Router, otp_app: :phoenix pipeline :browser do end scope "/" do pipe_through [:browser] scope "/nested" do pipe_through [:browser] end end end end end test "pipeline raises on conflict" do assert_raise ArgumentError, ~r{there is an import from Kernel with the same name}, fn -> defmodule ConflictingPipeline do use Phoenix.Router, otp_app: :phoenix pipeline :raise do plug Plug.Head end scope "/" do pipe_through [:raise] get "/", UnknownController, :index end end end end end ================================================ FILE: test/phoenix/router/resource_test.exs ================================================ defmodule Phoenix.Router.ResourceTest do use ExUnit.Case, async: true use RouterHelper defmodule Api.GenericController do use Phoenix.Controller, formats: [] def show(conn, _params), do: text(conn, "show") def new(conn, _params), do: text(conn, "new") def edit(conn, _params), do: text(conn, "edit") def create(conn, _params), do: text(conn, "create") def update(conn, _params), do: text(conn, "update") def delete(conn, _params), do: text(conn, "delete") end defmodule Router do use Phoenix.Router resources "/account", Api.GenericController, alias: Api, singleton: true do resources "/comments", GenericController resources "/session", GenericController, except: [:delete], singleton: true end resources "/session", Api.GenericController, only: [:show], singleton: true end setup do Logger.put_process_level(self(), :none) :ok end test "toplevel route matches new action" do conn = call(Router, :get, "/account/new") assert conn.status == 200 assert conn.resp_body == "new" end test "toplevel route matches show action" do conn = call(Router, :get, "/account") assert conn.status == 200 assert conn.resp_body == "show" end test "toplevel route matches edit action" do conn = call(Router, :get, "/account/edit") assert conn.status == 200 assert conn.resp_body == "edit" end test "toplevel route matches create action" do conn = call(Router, :post, "/account") assert conn.status == 200 assert conn.resp_body == "create" end test "toplevel route matches update action with both PUT and PATCH" do for method <- [:put, :patch] do conn = call(Router, method, "/account") assert conn.status == 200 assert conn.resp_body == "update" conn = call(Router, method, "/account") assert conn.status == 200 assert conn.resp_body == "update" end end test "toplevel route matches delete action" do conn = call(Router, :delete, "/account") assert conn.status == 200 assert conn.resp_body == "delete" end test "1-Level nested route matches" do conn = call(Router, :get, "/account/comments/2") assert conn.status == 200 assert conn.resp_body == "show" assert conn.params["id"] == "2" end test "nested prefix context reverts back to previous scope after expansion" do conn = call(Router, :get, "/account/session") assert conn.status == 200 assert conn.resp_body == "show" conn = call(Router, :get, "/session") assert conn.status == 200 assert conn.resp_body == "show" end test "limit resource by passing :except option" do assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :delete, "/account/session") end conn = call(Router, :get, "/account/session/new") assert conn.status == 200 end test "limit resource by passing :only option" do assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :patch, "/session/new") end conn = call(Router, :get, "/session") assert conn.status == 200 end end ================================================ FILE: test/phoenix/router/resources_test.exs ================================================ defmodule Phoenix.Router.ResourcesTest do use ExUnit.Case, async: true use RouterHelper defmodule UserController do use Phoenix.Controller, formats: [] def show(conn, _params), do: text(conn, "show users") def index(conn, _params), do: text(conn, "index users") def new(conn, _params), do: text(conn, "new users") def edit(conn, _params), do: text(conn, "edit users") def create(conn, _params), do: text(conn, "create users") def update(conn, _params), do: text(conn, "update users") def delete(conn, _params), do: text(conn, "delete users") end defmodule Api.FileController do use Phoenix.Controller, formats: [] def show(conn, _params), do: text(conn, "show files") def index(conn, _params), do: text(conn, "index files") def new(conn, _params), do: text(conn, "new files") end defmodule Api.CommentController do use Phoenix.Controller, formats: [] def show(conn, _params), do: text(conn, "show comments") def index(conn, _params), do: text(conn, "index comments") def new(conn, _params), do: text(conn, "new comments") def create(conn, _params), do: text(conn, "create comments") def update(conn, _params), do: text(conn, "update comments") def delete(conn, _params), do: text(conn, "delete comments") def special(conn, _params), do: text(conn, "special comments") end defmodule Router do use Phoenix.Router resources "/users", UserController, alias: Api do resources "/comments", CommentController do get "/special", CommentController, :special end resources "/files", FileController, except: [:delete] end resources "/members", UserController, only: [:show, :new, :delete] resources "/files", Api.FileController, only: [:index] resources "/admin", UserController, param: "slug", name: "admin", only: [:show], alias: Api do resources "/comments", CommentController, param: "key", name: "post", except: [:delete] resources "/files", FileController, only: [:show, :index, :new] end end setup do Logger.put_process_level(self(), :none) :ok end test "toplevel route matches new action" do conn = call(Router, :get, "/users/new") assert conn.status == 200 assert conn.resp_body == "new users" end test "toplevel route matches index action" do conn = call(Router, :get, "/users") assert conn.status == 200 assert conn.resp_body == "index users" end test "toplevel route matches show action with named param" do conn = call(Router, :get, "/users/123") assert conn.status == 200 assert conn.resp_body == "show users" assert conn.params["id"] == "123" end test "toplevel route matches edit action with named param" do conn = call(Router, :get, "/users/123/edit") assert conn.status == 200 assert conn.resp_body == "edit users" assert conn.params["id"] == "123" end test "toplevel route matches create action" do conn = call(Router, :post, "/users") assert conn.status == 200 assert conn.resp_body == "create users" end test "toplevel route matches update action with both PUT and PATCH" do for method <- [:put, :patch] do conn = call(Router, method, "/users/1") assert conn.status == 200 assert conn.resp_body == "update users" assert conn.params["id"] == "1" conn = call(Router, method, "/users/2") assert conn.status == 200 assert conn.resp_body == "update users" assert conn.params["id"] == "2" end end test "toplevel route matches delete action" do conn = call(Router, :delete, "/users/2") assert conn.status == 200 assert conn.resp_body == "delete users" assert conn.params["id"] == "2" end test "1-Level nested route matches with named param prefix on show" do conn = call(Router, :get, "/users/1/comments/2") assert conn.status == 200 assert conn.resp_body == "show comments" assert conn.params["id"] == "2" assert conn.params["user_id"] == "1" end test "1-Level nested route matches with named param prefix on index" do conn = call(Router, :get, "/users/1/comments") assert conn.status == 200 assert conn.resp_body == "index comments" assert conn.params["user_id"] == "1" end test "1-Level nested route matches with named param prefix on create" do conn = call(Router, :post, "/users/1/comments") assert conn.status == 200 assert conn.resp_body == "create comments" assert conn.params["user_id"] == "1" end test "1-Level nested route matches with named param prefix on update" do conn = call(Router, :patch, "/users/1/comments/123") assert conn.status == 200 assert conn.resp_body == "update comments" assert conn.params["user_id"] == "1" assert conn.params["id"] == "123" end test "1-Level nested route matches with named param prefix on delete" do conn = call(Router, :delete, "/users/1/comments/123") assert conn.status == 200 assert conn.resp_body == "delete comments" assert conn.params["user_id"] == "1" assert conn.params["id"] == "123" end test "2-Level nested route with get matches" do conn = call(Router, :get, "/users/1/comments/123/special") assert conn.status == 200 assert conn.resp_body == "special comments" assert conn.params["user_id"] == "1" assert conn.params["comment_id"] == "123" end test "nested prefix context reverts back to previous scope after expansion" do conn = call(Router, :get, "/users/8/files/10") assert conn.status == 200 assert conn.resp_body == "show files" assert conn.params["user_id"] == "8" assert conn.params["id"] == "10" conn = call(Router, :get, "/files") assert conn.status == 200 assert conn.resp_body == "index files" end test "nested options limit resource by passing :except option" do assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :delete, "/users/1/files/2") end conn = call(Router, :get, "/users/1/files/new") assert conn.status == 200 end test "nested options limit resource by passing :only option" do assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :patch, "/admin/1/files/2") end assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :post, "/admin/1/files") end assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :delete, "/admin/1/files/1") end conn = call(Router, :get, "/admin/1/files/") assert conn.status == 200 conn = call(Router, :get, "/admin/1/files/1") assert conn.status == 200 conn = call(Router, :get, "/admin/1/files/new") assert conn.status == 200 end test "resource limiting options should work for nested resources" do conn = call(Router, :get, "/admin/1") assert conn.status == 200 assert conn.resp_body == "show users" assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :get, "/admin/") end assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :patch, "/admin/1") end assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :post, "/admin") end assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :delete, "/admin/1") end conn = call(Router, :get, "/admin/1/comments") assert conn.status == 200 assert conn.resp_body == "index comments" conn = call(Router, :get, "/admin/1/comments/1") assert conn.status == 200 assert conn.resp_body == "show comments" conn = call(Router, :patch, "/admin/1/comments/1") assert conn.status == 200 assert conn.resp_body == "update comments" conn = call(Router, :post, "/admin/1/comments") assert conn.status == 200 assert conn.resp_body == "create comments" assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :delete, "/scoped_files/1") end end test "param option allows default singularized _id param to be overridden" do conn = call(Router, :get, "/admin/foo") assert conn.status == 200 assert conn.params["slug"] == "foo" assert conn.resp_body == "show users" assert Router.Helpers.admin_path(conn, :show, "foo") == "/admin/foo" conn = call(Router, :get, "/admin/bar/comments/the_key") assert conn.status == 200 assert conn.params["admin_slug"] == "bar" assert conn.params["key"] == "the_key" assert conn.resp_body == "show comments" assert Router.Helpers.admin_post_path(conn, :show, "bar", "the_key") == "/admin/bar/comments/the_key" end test "resources with :only sets proper match order for :show and :new" do conn = call(Router, :get, "/members/new") assert conn.status == 200 assert conn.resp_body == "new users" conn = call(Router, :get, "/members/2") assert conn.status == 200 assert conn.resp_body == "show users" assert conn.params["id"] == "2" end test "singleton resources declaring an :index route throws an ArgumentError" do assert_raise ArgumentError, ~r/supported singleton actions: \[:edit, :new, :show, :create, :update, :delete\]/, fn -> defmodule SingletonRouter.Router do use Phoenix.Router resources "/", UserController, singleton: true, only: [:index] end end end test "resources validates :only actions" do assert_raise ArgumentError, ~r/supported actions: \[:index, :edit, :new, :show, :create, :update, :delete\]/, fn -> defmodule SingletonRouter.Router do use Phoenix.Router resources "/", UserController, only: [:bad_index] end end end test "resources validates :except actions" do assert_raise ArgumentError, ~r/supported actions: \[:index, :edit, :new, :show, :create, :update, :delete\]/, fn -> defmodule SingletonRouter.Router do use Phoenix.Router resources "/", UserController, except: [:bad_index] end end end end ================================================ FILE: test/phoenix/router/route_test.exs ================================================ defmodule Phoenix.Router.RouteTest do use ExUnit.Case, async: true import Phoenix.Router.Route def init(opts), do: opts defmodule AdminRouter do def init(opts), do: opts def call(conn, _), do: Plug.Conn.assign(conn, :fwd_conn, conn) end test "builds a route based on verb, path, plug, plug options and helper" do route = build( 1, :match, :get, "/foo/:bar", [], Hello, :world, "hello_world", [:foo, :bar], %{foo: "bar"}, %{bar: "baz"}, %{log: :debug}, true, true ) assert route.kind == :match assert route.verb == :get assert route.path == "/foo/:bar" assert route.hosts == [] assert route.line == 1 assert route.plug == Hello assert route.plug_opts == :world assert route.helper == "hello_world" assert route.pipe_through == [:foo, :bar] assert route.private == %{foo: "bar"} assert route.assigns == %{bar: "baz"} assert route.metadata == %{log: :debug} assert route.trailing_slash? == true end test "builds expressions based on the route" do exprs = build( 1, :match, :get, "/foo/:bar", [], Hello, :world, "hello_world", [], %{}, %{}, %{}, false, true ) |> exprs() assert exprs.verb_match == "GET" assert exprs.path == ["foo", {:arg0, [], Phoenix.Router.Route}] assert exprs.binding == [{"bar", {:arg0, [], Phoenix.Router.Route}}] assert Macro.to_string(exprs.hosts) == "[_]" exprs = build( 1, :match, :get, "/", ["foo."], Hello, :world, "hello_world", [:foo, :bar], %{foo: "bar"}, %{bar: "baz"}, %{}, false, true ) |> exprs() assert Macro.to_string(exprs.hosts) == "[\"foo.\" <> _]" exprs = build( 1, :match, :get, "/", ["foo.", "example.com"], Hello, :world, "hello_world", [:foo, :bar], %{foo: "bar"}, %{bar: "baz"}, %{}, false, true ) |> exprs() assert Macro.to_string(exprs.hosts) == "[\"foo.\" <> _, \"example.com\"]" exprs = build( 1, :match, :get, "/", ["foo.com"], Hello, :world, "hello_world", [], %{foo: "bar"}, %{bar: "baz"}, %{}, false, true ) |> exprs() assert Macro.to_string(exprs.hosts) == "[\"foo.com\"]" end test "builds a catch-all verb_match for match routes" do route = build( 1, :match, :*, "/foo/:bar", [], __MODULE__, :world, "hello_world", [:foo, :bar], %{foo: "bar"}, %{bar: "baz"}, %{}, false, true ) assert route.verb == :* assert route.kind == :match assert exprs(route).verb_match == {:_verb, [], nil} end test "builds a catch-all verb_match for forwarded routes" do route = build( 1, :forward, :*, "/foo", [], __MODULE__, :world, "hello_world", [:foo], %{foo: "bar"}, %{bar: "baz"}, %{forward: ~w(foo)}, false, true ) assert route.verb == :* assert route.kind == :forward assert exprs(route).verb_match == {:_verb, [], nil} end test "as a plug, it forwards and sets path_info and script_name for target, then resumes" do conn = %Plug.Conn{path_info: ["admin", "stats"], script_name: ["phoenix"]} conn = call(conn, {["admin"], AdminRouter, []}) fwd_conn = conn.assigns[:fwd_conn] assert fwd_conn.path_info == ["stats"] assert fwd_conn.script_name == ["phoenix", "admin"] assert conn.path_info == ["admin", "stats"] assert conn.script_name == ["phoenix"] end end ================================================ FILE: test/phoenix/router/routing_test.exs ================================================ defmodule Phoenix.Router.RoutingTest do use ExUnit.Case, async: true use RouterHelper import ExUnit.CaptureLog defmodule SomePlug do def init(opts), do: opts def call(conn, _opts), do: conn end defmodule UserController do use Phoenix.Controller, formats: [] def index(conn, _params), do: text(conn, "users index") def show(conn, _params), do: text(conn, "users show") def top(conn, _params), do: text(conn, "users top") def options(conn, _params), do: text(conn, "users options") def connect(conn, _params), do: text(conn, "users connect") def trace(conn, _params), do: text(conn, "users trace") def not_found(conn, _params), do: text(put_status(conn, :not_found), "not found") def image(conn, _params), do: text(conn, conn.params["path"] || "show files") def move(conn, _params), do: text(conn, "users move") def any(conn, _params), do: text(conn, "users any") def raise(_conn, _params), do: raise("boom") def exit(_conn, _params), do: exit(:boom) def halt(conn, _params) do conn |> send_resp(401, "Unauthorized") |> halt() end end defmodule LogLevel do def log_level(%{params: %{"level" => "info"}}), do: :info def log_level(%{params: %{"level" => "error"}}), do: :error def log_level(_), do: :debug end defmodule Router do use Phoenix.Router get "/", UserController, :index, as: :users get "/users/top", UserController, :top, as: :top get "/users/:id", UserController, :show, as: :users, metadata: %{access: :user} match :*, "/users/fallback", UserController, :any get "/spaced users/:id", UserController, :show get "/profiles/profile-:id", UserController, :show get "/route_that_crashes", UserController, :crash get "/files/:user_name/*path", UserController, :image get "/backups/*path", UserController, :image get "/static/images/icons/*image", UserController, :image get "/exit", UserController, :exit get "/halt-controller", UserController, :halt trace("/trace", UserController, :trace) options "/options", UserController, :options connect "/connect", UserController, :connect match :move, "/move", UserController, :move match :*, "/any", UserController, :any scope log: :info do pipe_through :noop get "/plug", SomePlug, [] get "/users/:id/raise", UserController, :raise pipe_through :halt get "/info", UserController, :raise end get "/no_log", SomePlug, [], log: false get "/fun_log", SomePlug, [], log: {LogLevel, :log_level, []} get "/override-plug-name", SomePlug, :action, metadata: %{mfa: {LogLevel, :log_level, 1}} get "/users/:user_id/files/:id", UserController, :image scope "/halt-plug" do pipe_through :halt get "/", UserController, :raise end get "/*path", UserController, :not_found defp noop(conn, _), do: conn defp halt(conn, _) do conn |> Plug.Conn.send_resp(401, "Unauthorized") |> halt() end end setup do Logger.put_process_level(self(), :none) :ok end test "get root path" do conn = call(Router, :get, "/") assert conn.status == 200 assert conn.resp_body == "users index" end test "get to named param with dashes" do conn = call(Router, :get, "/users/75f6306d-a090-46f9-8b80-80fd57ec9a41") assert conn.status == 200 assert conn.resp_body == "users show" assert conn.params["id"] == "75f6306d-a090-46f9-8b80-80fd57ec9a41" assert conn.path_params["id"] == "75f6306d-a090-46f9-8b80-80fd57ec9a41" conn = call(Router, :get, "/users/75f6306d-a0/files/34-95") assert conn.status == 200 assert conn.resp_body == "show files" assert conn.params["user_id"] == "75f6306d-a0" assert conn.path_params["user_id"] == "75f6306d-a0" assert conn.params["id"] == "34-95" assert conn.path_params["id"] == "34-95" end test "get with named param" do conn = call(Router, :get, "/users/1") assert conn.status == 200 assert conn.resp_body == "users show" assert conn.params["id"] == "1" assert conn.path_params["id"] == "1" end test "get with named param and late query string fetch" do conn = conn(:get, "/users/1") |> Router.call(Router.init([])) |> fetch_query_params() assert conn.status == 200 assert conn.resp_body == "users show" assert conn.params["id"] == "1" assert conn.path_params["id"] == "1" conn = conn(:get, "/users/1?foo=bar") |> Router.call(Router.init([])) |> fetch_query_params() assert conn.status == 200 assert conn.resp_body == "users show" assert conn.params["id"] == "1" assert conn.params["foo"] == "bar" assert conn.path_params["id"] == "1" end test "parameters are url decoded" do conn = call(Router, :get, "/users/hello%20matey") assert conn.params == %{"id" => "hello matey"} conn = call(Router, :get, "/spaced%20users/hello%20matey") assert conn.params == %{"id" => "hello matey"} conn = call(Router, :get, "/spaced users/hello matey") assert conn.params == %{"id" => "hello matey"} conn = call(Router, :get, "/users/a%20b") assert conn.params == %{"id" => "a b"} conn = call(Router, :get, "/backups/a%20b/c%20d") assert conn.params == %{"path" => ["a b", "c d"]} end test "get to custom action" do conn = call(Router, :get, "/users/top") assert conn.status == 200 assert conn.resp_body == "users top" end test "options to custom action" do conn = call(Router, :options, "/options") assert conn.status == 200 assert conn.resp_body == "users options" end test "connect to custom action" do conn = call(Router, :connect, "/connect") assert conn.status == 200 assert conn.resp_body == "users connect" end test "trace to custom action" do conn = call(Router, :trace, "/trace") assert conn.status == 200 assert conn.resp_body == "users trace" end test "splat arg with preceding named parameter to files/:user_name/*path" do conn = call(Router, :get, "/files/elixir/Users/home/file.txt") assert conn.status == 200 assert conn.params["user_name"] == "elixir" assert conn.params["path"] == ["Users", "home", "file.txt"] end test "splat arg with preceding string to backups/*path" do conn = call(Router, :get, "/backups/name") assert conn.status == 200 assert conn.params["path"] == ["name"] end test "splat arg with multiple preceding strings to static/images/icons/*path" do conn = call(Router, :get, "/static/images/icons/elixir/logos/main.png") assert conn.status == 200 assert conn.params["image"] == ["elixir", "logos", "main.png"] end test "splat args are %encodings in path" do conn = call(Router, :get, "/backups/silly%20name") assert conn.status == 200 assert conn.params["path"] == ["silly name"] end test "catch-all splat route matches" do conn = call(Router, :get, "/foo/bar/baz") assert conn.status == 404 assert conn.params == %{"path" => ~w"foo bar baz"} assert conn.resp_body == "not found" end test "match on arbitrary http methods" do conn = call(Router, :move, "/move") assert conn.method == "MOVE" assert conn.status == 200 assert conn.resp_body == "users move" end test "any verb matches" do conn = call(Router, :get, "/any") assert conn.method == "GET" assert conn.status == 200 assert conn.resp_body == "users any" conn = call(Router, :put, "/any") assert conn.method == "PUT" assert conn.status == 200 assert conn.resp_body == "users any" end test "different verbs with similar paths" do conn = call(Router, :post, "/users/fallback") assert conn.status == 200 assert conn.resp_body == "users any" conn = call(Router, :get, "/users/123") assert conn.status == 200 assert conn.resp_body == "users show" assert conn.params["id"] == "123" assert conn.path_params["id"] == "123" end describe "logging" do setup do Logger.delete_process_level(self()) :ok end test "logs controller and action with (path) parameters" do assert capture_log(fn -> call(Router, :get, "/users/1", foo: "bar") end) =~ """ [debug] Processing with Phoenix.Router.RoutingTest.UserController.show/2 Parameters: %{"foo" => "bar", "id" => "1"} Pipelines: [] """ end test "logs controller and action with filtered parameters" do assert capture_log(fn -> call(Router, :get, "/users/1", password: "bar") end) =~ """ [debug] Processing with Phoenix.Router.RoutingTest.UserController.show/2 Parameters: %{"id" => "1", "password" => "[FILTERED]"} Pipelines: [] """ end test "logs plug with pipeline and custom level" do assert capture_log(fn -> call(Router, :get, "/plug") end) =~ """ [info] Processing with Phoenix.Router.RoutingTest.SomePlug Parameters: %{} Pipelines: [:noop] """ end test "does not log when log is set to false" do refute capture_log(fn -> call(Router, :get, "/no_log", foo: "bar") end) =~ "Processing with Phoenix.Router.RoutingTest.SomePlug" end test "overrides plug name that processes the route when set in metadata" do assert capture_log(fn -> call(Router, :get, "/override-plug-name") end) =~ "Processing with Phoenix.Router.RoutingTest.LogLevel.log_level/1" end test "logs custom level when log is set to a 1-arity function" do assert capture_log(fn -> call(Router, :get, "/fun_log", level: "info") end) =~ "[info] Processing with Phoenix.Router.RoutingTest.SomePlug" assert capture_log(fn -> call(Router, :get, "/fun_log", level: "error") end) =~ "[error] Processing with Phoenix.Router.RoutingTest.SomePlug" assert capture_log(fn -> call(Router, :get, "/fun_log", level: "yelling") end) =~ "[debug] Processing with Phoenix.Router.RoutingTest.SomePlug" assert capture_log(fn -> call(Router, :get, "/fun_log") end) =~ "[debug] Processing with Phoenix.Router.RoutingTest.SomePlug" end end describe "telemetry" do @router_start_event [:phoenix, :router_dispatch, :start] @router_stop_event [:phoenix, :router_dispatch, :stop] @router_exception_event [:phoenix, :router_dispatch, :exception] @router_events [ @router_start_event, @router_stop_event, @router_exception_event ] setup context do test_pid = self() test_name = context.test :telemetry.attach_many( test_name, @router_events, fn event, measures, metadata, config -> send(test_pid, {:telemetry_event, event, {measures, metadata, config}}) end, nil ) on_exit(fn -> :telemetry.detach(test_name) end) end test "phoenix.router_dispatch.start and .stop are emitted on success" do call(Router, :get, "/users/123") assert_received {:telemetry_event, @router_start_event, {_, %{route: "/users/:id"}, _}} assert_received {:telemetry_event, @router_stop_event, {_, %{route: "/users/:id"}, _}} refute_received {:telemetry_event, @router_exception_event, {_, %{route: "/users/:id"}, _}} end test "phoenix.router_dispatch.start and .stop are emitted when conn halted in router" do conn = call(Router, :get, "/halt-plug") assert conn.halted assert conn.status == 401 assert_received {:telemetry_event, @router_start_event, {_, %{route: "/halt-plug"}, _}} assert_received {:telemetry_event, @router_stop_event, {_, %{route: "/halt-plug"}, _}} refute_received {:telemetry_event, @router_exception_event, {_, %{route: "/halt-plug"}, _}} end test "phoenix.router_dispatch.start and .stop are emitted when conn is halted in controller" do conn = call(Router, :get, "/halt-controller") assert conn.halted assert conn.status == 401 assert_received {:telemetry_event, @router_start_event, {_, %{route: "/halt-controller"}, _}} assert_received {:telemetry_event, @router_stop_event, {_, %{route: "/halt-controller"}, _}} refute_received {:telemetry_event, @router_exception_event, {_, %{route: "/halt-controller"}, _}} end test "phoenix.router_dispatch.start and .exception are emitted on crash" do assert_raise Plug.Conn.WrapperError, ~r/UndefinedFunctionError/, fn -> call(Router, :get, "/route_that_crashes") end assert_received {:telemetry_event, @router_start_event, {_, %{route: "/route_that_crashes"}, _}} assert_received {:telemetry_event, @router_exception_event, {_, %{route: "/route_that_crashes"}, _}} refute_received {:telemetry_event, @router_stop_event, {_, %{route: "/route_that_crashes"}, _}} end test "phoenix.router_dispatch.start and .exception are emitted on exit" do catch_exit(call(Router, :get, "/exit")) assert_received {:telemetry_event, @router_start_event, {_, %{route: "/exit"}, _}} assert_received {:telemetry_event, @router_exception_event, {_, %{route: "/exit"}, _}} refute_received {:telemetry_event, @router_stop_event, {_, %{route: "/exit"}, _}} end test "phoenix.router_dispatch.start has supported measurements and metadata" do call(Router, :get, "/users/123") assert_received {:telemetry_event, @router_start_event, {measures, %{route: "/users/:id"} = meta, _config}} assert is_integer(measures.system_time) assert %{ access: :user, conn: %Plug.Conn{state: :unset}, log: :debug, path_params: %{"id" => "123"}, pipe_through: [], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :show, route: "/users/:id" } = meta end test "phoenix.router_dispatch.stop has supported measurements and metadata" do call(Router, :get, "/users/123") assert_received {:telemetry_event, @router_stop_event, {measures, %{route: "/users/:id"} = meta, _config}} assert is_integer(measures.duration) assert %{ access: :user, conn: %Plug.Conn{state: :sent}, log: :debug, path_params: %{"id" => "123"}, pipe_through: [], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :show, route: "/users/:id" } = meta end test "phoenix.router_dispatch.exception has supported measurements and metadata on crash" do assert_raise Plug.Conn.WrapperError, "** (RuntimeError) boom", fn -> call(Router, :get, "/users/123/raise") end assert_received {:telemetry_event, @router_exception_event, {measures, %{route: "/users/:id/raise"} = meta, _config}} assert is_integer(measures.duration) assert %{ conn: %Plug.Conn{state: :unset}, kind: :error, log: :info, path_params: %{"id" => "123"}, pipe_through: [:noop], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :raise, reason: %Plug.Conn.WrapperError{ conn: %Plug.Conn{state: :unset}, kind: :error, reason: %RuntimeError{message: "boom"}, stack: wrapped_stacktrace }, route: "/users/:id/raise", stacktrace: stacktrace } = meta assert is_list(wrapped_stacktrace) && length(wrapped_stacktrace) > 0 assert is_list(stacktrace) && length(stacktrace) > 0 end test "phoenix.router_dispatch.exception has supported measurements and metadata on exit" do catch_exit(call(Router, :get, "/exit")) assert_received {:telemetry_event, @router_exception_event, {measures, %{route: "/exit"} = meta, _config}} assert is_integer(measures.duration) assert %{ conn: %Plug.Conn{state: :unset}, kind: :exit, log: :debug, path_params: %{}, pipe_through: [], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :exit, reason: :boom, route: "/exit", stacktrace: stacktrace } = meta assert is_list(stacktrace) && length(stacktrace) > 0 end end describe "route_info" do test " returns route string, path params, and more" do assert Phoenix.Router.route_info(Router, "GET", "foo/bar/baz", nil) == %{ log: :debug, path_params: %{"path" => ["foo", "bar", "baz"]}, pipe_through: [], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :not_found, route: "/*path" } assert Phoenix.Router.route_info(Router, "GET", "users/1", nil) == %{ log: :debug, path_params: %{"id" => "1"}, pipe_through: [], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :show, route: "/users/:id", access: :user } assert Phoenix.Router.route_info(Router, "GET", "/", "host") == %{ log: :debug, path_params: %{}, pipe_through: [], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :index, route: "/" } assert Phoenix.Router.route_info(Router, "POST", "/not-exists", "host") == :error end test "returns route string, path params and more for split path" do assert Phoenix.Router.route_info(Router, "GET", ~w(foo bar baz), nil) == %{ log: :debug, path_params: %{"path" => ["foo", "bar", "baz"]}, pipe_through: [], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :not_found, route: "/*path" } end test "returns accumulated pipe_through metadata" do assert Phoenix.Router.route_info(Router, "GET", "/info", nil) == %{ log: :info, path_params: %{}, pipe_through: [:noop, :halt], plug: Phoenix.Router.RoutingTest.UserController, plug_opts: :raise, route: "/info" } end end end ================================================ FILE: test/phoenix/router/scope_test.exs ================================================ defmodule Phoenix.Router.ScopedRoutingTest do use ExUnit.Case, async: true use RouterHelper # Path scoping defmodule Api.V1.UserController do use Phoenix.Controller, formats: [] def show(conn, _params), do: text(conn, "api v1 users show") def delete(conn, _params), do: text(conn, "api v1 users delete") def edit(conn, _params), do: text(conn, "api v1 users edit") def foo_host(conn, _params), do: text(conn, "foo request from #{conn.host}") def baz_host(conn, _params), do: text(conn, "baz request from #{conn.host}") def multi_host(conn, _params), do: text(conn, "multi_host request from #{conn.host}") def other_subdomain(conn, _params), do: text(conn, "other_subdomain request from #{conn.host}") def proxy(conn, _) do {controller, action} = conn.private.proxy_to controller.call(conn, controller.init(action)) end end defmodule Api.V1.VenueController do def init(opts), do: opts def call(conn, _opts), do: conn end defmodule :erlang_like do def init(action), do: action def call(conn, action), do: Plug.Conn.send_resp(conn, 200, "Erlang like #{action}") end defmodule Router do use Phoenix.Router scope "/admin", host: "baz." do get "/users/:id", Api.V1.UserController, :baz_host end scope host: "foobar.com" do scope "/admin" do get "/users/:id", Api.V1.UserController, :foo_host end end scope "/admin" do get "/erlang/like", :erlang_like, :action, as: :erlang_like get "/users/:id", Api.V1.UserController, :show end scope "/api" do scope "/v1" do get "/users/:id", Api.V1.UserController, :show end end scope "/api", Api, private: %{private_token: "foo"} do get "/users", V1.UserController, :show get "/users/:id", V1.UserController, :show, private: %{private_token: "bar"} scope "/v1", alias: V1 do resources "/users", UserController, only: [:delete], private: %{private_token: "baz"} get "/noalias", Api.V1.UserController, :proxy, private: %{proxy_to: {scoped_alias(__MODULE__, UserController), :show}}, alias: false scope "/scoped", alias: false do get "/noalias", Api.V1.UserController, :proxy, private: %{proxy_to: {scoped_alias(__MODULE__, Api.V1.UserController), :show}} end end end scope "/assigns", Api, assigns: %{assigns_token: "foo"} do get "/users", V1.UserController, :show get "/users/:id", V1.UserController, :show, assigns: %{assigns_token: "bar"} scope "/v1", alias: V1 do resources "/users", UserController, only: [:delete], assigns: %{assigns_token: "baz"} end end scope "/host", host: "baz." do get "/users/:id", Api.V1.UserController, :baz_host end scope host: "foobar.com" do scope "/host" do get "/users/:id", Api.V1.UserController, :foo_host end end scope "/api" do scope "/v1", Api do resources "/venues", V1.VenueController, only: [:show], alias: V1 do resources "/users", UserController, only: [:edit] end end end # match www, no subdomain, and localhost scope "/multi_host", host: ["www.", "example.com", "localhost"] do get "/", Api.V1.UserController, :multi_host end # matched logged in subdomain user homepages scope "/multi_host" do get "/", Api.V1.UserController, :other_subdomain end end setup do Logger.put_process_level(self(), :none) :ok end test "single scope for single routes" do conn = call(Router, :get, "/admin/users/1") assert conn.status == 200 assert conn.resp_body == "api v1 users show" assert conn.params["id"] == "1" conn = call(Router, :get, "/api/users/13") assert conn.status == 200 assert conn.resp_body == "api v1 users show" assert conn.params["id"] == "13" end test "single scope with Erlang like route" do conn = call(Router, :get, "/admin/erlang/like") assert conn.status == 200 assert conn.resp_body == "Erlang like action" end test "double scope for single routes" do conn = call(Router, :get, "/api/v1/users/1") assert conn.status == 200 assert conn.resp_body == "api v1 users show" assert conn.params["id"] == "1" end test "scope for resources" do conn = call(Router, :delete, "/api/v1/users/12") assert conn.status == 200 assert conn.resp_body == "api v1 users delete" assert conn.params["id"] == "12" end test "scope for double nested resources" do conn = call(Router, :get, "/api/v1/venues/12/users/13/edit") assert conn.status == 200 assert conn.resp_body == "api v1 users edit" assert conn.params["venue_id"] == "12" assert conn.params["id"] == "13" end test "host scopes routes based on conn.host" do conn = call(Router, :get, "http://foobar.com/admin/users/1") assert conn.status == 200 assert conn.resp_body == "foo request from foobar.com" assert conn.params["id"] == "1" end test "host scopes allows partial host matching" do conn = call(Router, :get, "http://baz.bing.com/admin/users/1") assert conn.status == 200 assert conn.resp_body == "baz request from baz.bing.com" conn = call(Router, :get, "http://baz.pang.com/admin/users/1") assert conn.status == 200 assert conn.resp_body == "baz request from baz.pang.com" end test "host scopes allows list of hosts" do conn = call(Router, :get, "http://www.example.com/multi_host") assert conn.status == 200 assert conn.resp_body == "multi_host request from www.example.com" conn = call(Router, :get, "http://www.anotherwww.com/multi_host") assert conn.status == 200 assert conn.resp_body == "multi_host request from www.anotherwww.com" conn = call(Router, :get, "http://localhost/multi_host") assert conn.status == 200 assert conn.resp_body == "multi_host request from localhost" conn = call(Router, :get, "http://subdomain.example.com/multi_host") assert conn.status == 200 assert conn.resp_body == "other_subdomain request from subdomain.example.com" end test "host 404s when failed match" do conn = call(Router, :get, "http://foobar.com/host/users/1") assert conn.status == 200 conn = call(Router, :get, "http://baz.pang.com/host/users/1") assert conn.status == 200 assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :get, "http://foobar.com.br/host/users/1") end assert_raise Phoenix.Router.NoRouteError, fn -> call(Router, :get, "http://ba.pang.com/host/users/1") end end test "bad host raises" do assert_raise ArgumentError, "expected router scope :host to be compile-time string or list of strings, got: nil", fn -> defmodule BadRouter do use Phoenix.Router scope "/admin", host: ["foo.", nil] do get "/users/:id", Api.V1.UserController, :baz_host end end end end test "private data in scopes" do conn = call(Router, :get, "/api/users") assert conn.status == 200 assert conn.private[:private_token] == "foo" conn = call(Router, :get, "/api/users/13") assert conn.status == 200 assert conn.private[:private_token] == "bar" conn = call(Router, :delete, "/api/v1/users/13") assert conn.status == 200 assert conn.private[:private_token] == "baz" end test "assigns data in scopes" do conn = call(Router, :get, "/assigns/users") assert conn.status == 200 assert conn.assigns[:assigns_token] == "foo" conn = call(Router, :get, "/assigns/users/13") assert conn.status == 200 assert conn.assigns[:assigns_token] == "bar" conn = call(Router, :delete, "/assigns/v1/users/13") assert conn.status == 200 assert conn.assigns[:assigns_token] == "baz" end test "string paths are enforced" do assert_raise ArgumentError, ~r{router paths must be strings, got: :bar}, fn -> defmodule SomeRouter do use Phoenix.Router, otp_app: :phoenix get :bar, Router, [] end end assert_raise ArgumentError, ~r{router paths must be strings, got: :bar}, fn -> defmodule SomeRouter do use Phoenix.Router, otp_app: :phoenix get "/foo", Router, [] scope "/another" do resources :bar, Router, [] end end end end test "alias false with expanded scoped alias via option" do conn = call(Router, :get, "/api/v1/noalias") assert conn.status == 200 assert conn.resp_body == "api v1 users show" end test "alias false with expanded scoped alias via scope" do conn = call(Router, :get, "/api/v1/scoped/noalias") assert conn.status == 200 assert conn.resp_body == "api v1 users show" end test "raises for reserved prefixes" do assert_raise ArgumentError, ~r/`static` is a reserved route prefix/, fn -> defmodule ErrorRouter do use Phoenix.Router scope "/" do get "/", StaticController, :index end end end assert_raise ArgumentError, ~r/`static` is a reserved route prefix/, fn -> defmodule ErrorRouter do use Phoenix.Router scope "/" do get "/", Api.V1.UserController, :show, as: :static end end end end end ================================================ FILE: test/phoenix/socket/message_test.exs ================================================ defmodule Phoenix.Socket.MessageTest do use ExUnit.Case, async: true doctest Phoenix.Socket.Message alias Phoenix.Socket.Message describe "inspect/2 custom implementation" do test "filters sensitive values in form submit events" do message = %Message{ topic: "lv:1", event: "event", payload: %{ "event" => "submit", "type" => "form", "value" => "username=john&password=secret123&email=john@example.com" }, ref: "1", join_ref: "1" } assert inspect(message) =~ "\"value\" => \"[FILTERED]\"" end test "filters sensitive values at the end of form submit events" do message = %Message{ topic: "lv:1", event: "event", payload: %{ "event" => "submit", "type" => "form", "value" => "username=john&password=secret123" }, ref: "1", join_ref: "1" } assert inspect(message) =~ "\"value\" => \"[FILTERED]\"" end test "handles malformed query strings gracefully" do message = %Message{ topic: "lv:1", event: "event", payload: %{ "event" => "submit", "type" => "form", "value" => "invalid=query=string&password=secret" }, ref: "1", join_ref: "1" } assert inspect(message) =~ "\"value\" => \"[FILTERED]\"" end end end ================================================ FILE: test/phoenix/socket/socket_test.exs ================================================ defmodule Phoenix.SocketTest do use ExUnit.Case, async: true import Phoenix.Socket alias Phoenix.Socket.{Message, InvalidMessageError} defmodule UserSocket do use Phoenix.Socket channel "food*", FoodChannel channel "foo*", FooChannel def connect(_params, socket, _connect_info), do: {:ok, socket} def id(_socket), do: nil end describe "__channel__" do test "returns the correct channel handler module" do assert {FooChannel, []} == UserSocket.__channel__("foo:1") assert {FoodChannel, []} == UserSocket.__channel__("food:1") assert nil == UserSocket.__channel__("unknown") end end describe "messages" do test "from_map! converts a map with string keys into a %Message{}" do msg = Message.from_map!(%{"topic" => "c", "event" => "e", "payload" => "", "ref" => "r"}) assert msg == %Message{topic: "c", event: "e", payload: "", ref: "r"} end test "from_map! raises InvalidMessageError when any required key" do assert_raise InvalidMessageError, fn -> Message.from_map!(%{"event" => "e", "payload" => "", "ref" => "r"}) end assert_raise InvalidMessageError, fn -> Message.from_map!(%{"topic" => "c", "payload" => "", "ref" => "r"}) end assert_raise InvalidMessageError, fn -> Message.from_map!(%{"topic" => "c", "event" => "e", "ref" => "r"}) end assert_raise InvalidMessageError, fn -> Message.from_map!(%{"topic" => "c", "event" => "e"}) end end end describe "assign/3" do test "assigns to socket" do socket = %Phoenix.Socket{} assert socket.assigns[:foo] == nil socket = assign(socket, :foo, :bar) assert socket.assigns[:foo] == :bar end end describe "assign/2" do test "assigns a map socket" do socket = %Phoenix.Socket{} assert socket.assigns[:foo] == nil socket = assign(socket, %{foo: :bar, abc: :def}) assert socket.assigns[:foo] == :bar assert socket.assigns[:abc] == :def end test "merges if values exist" do socket = %Phoenix.Socket{} socket = assign(socket, %{foo: :bar, abc: :def}) socket = assign(socket, %{foo: :baz}) assert socket.assigns[:foo] == :baz assert socket.assigns[:abc] == :def end test "merges keyword lists" do socket = %Phoenix.Socket{} socket = assign(socket, %{foo: :bar, abc: :def}) socket = assign(socket, foo: :baz) assert socket.assigns[:foo] == :baz assert socket.assigns[:abc] == :def end test "accepts functions" do socket = %Phoenix.Socket{} assert socket.assigns[:foo] == nil socket = assign(socket, :foo, :bar) assert socket.assigns[:foo] == :bar socket = assign(socket, fn %{foo: :bar} -> [baz: :quux] end) assert socket.assigns[:baz] == :quux end end describe "drainer_spec/1" do defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix end defmodule DrainerSpecSocket do use Phoenix.Socket def id(_), do: "123" def dynamic_drainer_config do [ batch_size: 200, batch_interval: 2_000, shutdown: 20_000 ] end end test "loads static drainer config" do drainer_spec = [ batch_size: 100, batch_interval: 1_000, shutdown: 10_000 ] assert DrainerSpecSocket.drainer_spec(drainer: drainer_spec, endpoint: Endpoint) == {Phoenix.Socket.PoolDrainer, {Endpoint, DrainerSpecSocket, [endpoint: Endpoint, drainer: drainer_spec]}} end test "loads dynamic drainer config" do drainer_spec = DrainerSpecSocket.dynamic_drainer_config() assert DrainerSpecSocket.drainer_spec( drainer: {DrainerSpecSocket, :dynamic_drainer_config, []}, endpoint: Endpoint ) == {Phoenix.Socket.PoolDrainer, {Endpoint, DrainerSpecSocket, [endpoint: Endpoint, drainer: drainer_spec]}} end test "returns ignore if drainer is set to false" do assert DrainerSpecSocket.drainer_spec(drainer: false, endpoint: Endpoint) == :ignore end end end ================================================ FILE: test/phoenix/socket/transport_test.exs ================================================ defmodule Phoenix.Socket.TransportTest do use ExUnit.Case, async: true use RouterHelper import ExUnit.CaptureLog alias Phoenix.Socket.Transport @secret_key_base String.duplicate("abcdefgh", 8) Application.put_env(:phoenix, __MODULE__.Endpoint, force_ssl: [], url: [host: "host.com"], check_origin: ["//endpoint.com"], secret_key_base: @secret_key_base ) defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix @session_config [ store: :cookie, key: "_hello_key", signing_salt: "change_me" ] def session_config(overrides \\ []), do: Keyword.merge(@session_config, overrides) plug Plug.Session, @session_config plug :fetch_session plug :put_csrf plug :put_session defp put_csrf(conn, _opts) do conn = Plug.Conn.fetch_query_params(conn) session_key = Map.get(conn.query_params, "session_key", "_csrf_token") opts = Plug.CSRFProtection.init(session_key: session_key) Plug.CSRFProtection.call(conn, opts) end defp put_session(conn, _) do conn |> put_session(:from_session, "123") |> send_resp(200, Plug.CSRFProtection.get_csrf_token()) end end setup_all do Endpoint.start_link() :ok end setup do Logger.put_process_level(self(), :none) end ## Check origin describe "check_origin/4" do defp check_origin(%Plug.Conn{} = conn, origin, opts) do conn = put_req_header(conn, "origin", origin) Transport.check_origin(conn, make_ref(), Endpoint, opts) end defp check_origin(origin, opts), do: check_origin(conn(:get, "/"), origin, opts) test "does not check origin if disabled" do refute check_origin("/", check_origin: false).halted end test "checks origin against host" do refute check_origin("https://host.com/", check_origin: true).halted conn = check_origin("https://another.com/", check_origin: true) assert conn.halted assert conn.status == 403 end test "checks origin from endpoint config" do refute check_origin("https://endpoint.com/", []).halted conn = check_origin("https://another.com/", []) assert conn.halted assert conn.status == 403 end test "can get the host from system variables" do refute check_origin("https://host.com", check_origin: true).halted end test "wildcard subdomains" do origins = ["https://*.ex.com", "http://*.ex.com"] conn = check_origin("http://org1.ex.com", check_origin: origins) refute conn.halted conn = check_origin("https://org1.ex.com", check_origin: origins) refute conn.halted conn = check_origin("https://ex.com", check_origin: origins) refute conn.halted conn = check_origin("https://org1.prefix-ex.com", check_origin: origins) assert conn.halted end test "nested wildcard subdomains" do origins = ["http://*.foo.example.com"] conn = check_origin("http://org1.foo.example.com", check_origin: origins) refute conn.halted conn = check_origin("http://foo.example.com", check_origin: origins) refute conn.halted conn = check_origin("http://bad.example.com", check_origin: origins) assert conn.halted conn = check_origin("http://org1.prefix-foo.example.com", check_origin: origins) assert conn.halted conn = check_origin("http://org1.bar.example.com", check_origin: origins) assert conn.halted assert conn.status == 403 end test "subdomains do not match without a wildcard" do conn = check_origin("http://org1.ex.com", check_origin: ["//ex.com"]) assert conn.halted end test "halts invalid URIs when check origin is configured" do Logger.delete_process_level(self()) origins = ["//example.com", "http://scheme.com", "//port.com:81"] logs = capture_log(fn -> for config <- [origins, true] do assert check_origin("file://", check_origin: config).halted assert check_origin("null", check_origin: config).halted assert check_origin("", check_origin: config).halted end end) assert logs =~ "Origin of the request: file://" assert logs =~ "Origin of the request: null" end def invalid_allowed?(%URI{host: nil}), do: true def invalid_allowed?(%URI{host: ""}), do: true test "allows custom MFA check to handle invalid host" do mfa = {__MODULE__, :invalid_allowed?, []} refute check_origin("file://", check_origin: mfa).halted refute check_origin("null", check_origin: mfa).halted refute check_origin("", check_origin: mfa).halted end test "checks origin against :conn" do conn = %{conn(:get, "/") | host: "example.com", scheme: :http, port: 80} refute check_origin(conn, "http://example.com", check_origin: :conn).halted assert check_origin(conn, "https://example.com", check_origin: :conn).halted assert check_origin(conn, "ws://example.com", check_origin: :conn).halted assert check_origin(conn, "wss://example.com", check_origin: :conn).halted assert check_origin(conn, "http://www.example.com", check_origin: :conn).halted assert check_origin(conn, "http://www.another.com", check_origin: :conn).halted conn = %{conn(:get, "/") | host: "example.com", scheme: :https, port: 443} refute check_origin(conn, "https://example.com", check_origin: :conn).halted assert check_origin(conn, "http://example.com", check_origin: :conn).halted assert check_origin(conn, "https://example.com:4000", check_origin: :conn).halted end test "does not halt invalid URIs when check_origin is disabled" do refute check_origin("file://", check_origin: false).halted refute check_origin("null", check_origin: false).halted refute check_origin("", check_origin: false).halted end test "checks the origin of requests against allowed origins" do origins = ["//example.com", "http://scheme.com", "//port.com:81"] # not allowed host conn = check_origin("http://notallowed.com/", check_origin: origins) assert conn.halted assert conn.status == 403 # Only host match refute check_origin("http://example.com/", check_origin: origins).halted refute check_origin("https://example.com/", check_origin: origins).halted # Scheme + host match (checks port due to scheme) refute check_origin("http://scheme.com/", check_origin: origins).halted conn = check_origin("https://scheme.com/", check_origin: origins) assert conn.halted assert conn.status == 403 conn = check_origin("http://scheme.com:8080/", check_origin: origins) assert conn.halted assert conn.status == 403 # Scheme + host + port match refute check_origin("http://port.com:81/", check_origin: origins).halted conn = check_origin("http://port.com:82/", check_origin: origins) assert conn.halted assert conn.status == 403 end def check_origin_callback(%URI{host: "example.com"}), do: true def check_origin_callback(%URI{host: _}), do: false test "checks the origin of requests against an MFA" do # callback without additional arguments mfa = {__MODULE__, :check_origin_callback, []} # a not allowed host conn = check_origin("http://notallowed.com/", check_origin: mfa) assert conn.halted assert conn.status == 403 # an allowed host refute check_origin("http://example.com/", check_origin: mfa).halted end def check_origin_additional(%URI{host: allowed}, allowed), do: true def check_origin_additional(%URI{host: _}, _allowed), do: false test "checks the origin of requests against an MFA, passing additional arguments" do # callback with additional argument mfa = {__MODULE__, :check_origin_additional, ["host.com"]} # a not allowed host conn = check_origin("http://notallowed.com/", check_origin: mfa) assert conn.halted assert conn.status == 403 # an allowed host refute check_origin("https://host.com/", check_origin: mfa).halted end end ## Check subprotocols describe "check_subprotocols/2" do defp check_subprotocols(expected, passed) do conn = conn(:get, "/") |> put_req_header("sec-websocket-protocol", Enum.join(passed, ", ")) Transport.check_subprotocols(conn, expected) end test "does not check subprotocols if not passed expected" do refute check_subprotocols(nil, ["sip"]).halted end test "does not check subprotocols if conn is halted" do halted_conn = conn(:get, "/") |> halt() conn = Transport.check_subprotocols(halted_conn, ["sip"]) assert conn == halted_conn end test "returns first matched subprotocol" do conn = check_subprotocols(["sip", "mqtt"], ["sip", "mqtt"]) refute conn.halted assert get_resp_header(conn, "sec-websocket-protocol") == ["sip"] end test "halt if expected and passed subprotocols don't match" do conn = check_subprotocols(["sip"], ["mqtt"]) assert conn.halted assert conn.status == 403 end test "halt if expected subprotocols passed in the wrong format" do conn = check_subprotocols("sip", ["mqtt"]) assert conn.halted assert conn.status == 403 end end describe "connect_info/4" do defp load_connect_info(connect_info) do [connect_info: connect_info] = Transport.load_config(connect_info: connect_info) connect_info end test "loads the session from MFA" do conn = conn(:get, "https://foo.com/") |> Endpoint.call([]) csrf_token = conn.resp_body session_cookie = conn.cookies["_hello_key"] connect_info = load_connect_info(session: {Endpoint, :session_config, []}) assert %{session: %{"from_session" => "123"}} = conn(:get, "https://foo.com/", _csrf_token: csrf_token) |> put_req_cookie("_hello_key", session_cookie) |> fetch_query_params() |> Transport.connect_info(Endpoint, connect_info) end test "loads the session with custom :csrf_token_key" do conn = conn(:get, "https://foo.com?session_key=_custom_csrf_token") |> Endpoint.call([]) csrf_token = conn.resp_body session_cookie = conn.cookies["_hello_key"] connect_info = load_connect_info( session: { Endpoint, :session_config, [[csrf_token_key: "_custom_csrf_token"]] } ) assert %{session: %{"from_session" => "123"}} = conn(:get, "https://foo.com/", _csrf_token: csrf_token) |> put_req_cookie("_hello_key", session_cookie) |> fetch_query_params() |> Transport.connect_info(Endpoint, connect_info) connect_info = load_connect_info( session: { Endpoint, :session_config, [[csrf_token_key: "bad_key"]] } ) assert %{session: nil} = conn(:get, "https://foo.com/", _csrf_token: csrf_token) |> put_req_cookie("_hello_key", session_cookie) |> fetch_query_params() |> Transport.connect_info(Endpoint, connect_info) end test "loads the session when CSRF is disabled despite CSRF token not being provided" do conn = conn(:get, "https://foo.com/") |> Endpoint.call([]) session_cookie = conn.cookies["_hello_key"] connect_info = load_connect_info(session: {Endpoint, :session_config, []}) assert %{session: %{"from_session" => "123"}} = conn(:get, "https://foo.com/") |> put_req_cookie("_hello_key", session_cookie) |> fetch_query_params() |> Transport.connect_info(Endpoint, connect_info, check_csrf: false) end test "doesn't load session when an invalid CSRF token is provided" do conn = conn(:get, "https://foo.com/") |> Endpoint.call([]) invalid_csrf_token = "some invalid CSRF token" session_cookie = conn.cookies["_hello_key"] connect_info = load_connect_info(session: {Endpoint, :session_config, []}) assert %{session: nil} = conn(:get, "https://foo.com/", _csrf_token: invalid_csrf_token) |> put_req_cookie("_hello_key", session_cookie) |> fetch_query_params() |> Transport.connect_info(Endpoint, connect_info) end end end ================================================ FILE: test/phoenix/socket/v1_json_serializer_test.exs ================================================ defmodule Phoenix.Socket.V1.JSONSerializerTest do use ExUnit.Case, async: true alias Phoenix.Socket.{Broadcast, Message, Reply, V1} # v1 responses must not contain join_ref @serializer V1.JSONSerializer @v1_msg_json "{\"event\":\"e\",\"payload\":\"m\",\"ref\":null,\"topic\":\"t\"}" @v1_bad_json "[null,null,\"t\",\"e\",{\"m\":1}]" def encode!(serializer, msg) do {:socket_push, :text, encoded} = serializer.encode!(msg) IO.iodata_to_binary(encoded) end def decode!(serializer, msg, opts), do: serializer.decode!(msg, opts) def fastlane!(serializer, msg) do {:socket_push, :text, encoded} = serializer.fastlane!(msg) IO.iodata_to_binary(encoded) end test "encode!/1 encodes `Phoenix.Socket.Message` as JSON" do msg = %Message{topic: "t", event: "e", payload: "m"} encoded = encode!(@serializer, msg) assert Jason.decode!(encoded) == %{ "event" => "e", "payload" => "m", "ref" => nil, "topic" => "t" } end test "encode!/1 encodes `Phoenix.Socket.Reply` as JSON" do msg = %Reply{topic: "t", ref: "null"} encoded = encode!(@serializer, msg) assert Jason.decode!(encoded) == %{ "event" => "phx_reply", "payload" => %{"response" => nil, "status" => nil}, "ref" => "null", "topic" => "t" } end test "decode!/2 decodes `Phoenix.Socket.Message` from JSON" do assert %Message{topic: "t", event: "e", payload: "m"} == decode!(@serializer, @v1_msg_json, opcode: :text) end test "decode!/2 raise a PayloadFormatException if the JSON doesn't contain a map" do assert_raise( RuntimeError, "V1 JSON Serializer expected a map, got [nil, nil, \"t\", \"e\", %{\"m\" => 1}]", fn -> decode!(@serializer, @v1_bad_json, opcode: :text) end ) end test "fastlane!/1 encodes a broadcast into a message as JSON" do msg = %Broadcast{topic: "t", event: "e", payload: "m"} encoded = fastlane!(@serializer, msg) assert Jason.decode!(encoded) == %{ "event" => "e", "payload" => "m", "ref" => nil, "topic" => "t" } end end ================================================ FILE: test/phoenix/socket/v2_json_serializer_test.exs ================================================ defmodule Phoenix.Socket.V2.JSONSerializerTest do use ExUnit.Case, async: true alias Phoenix.Socket.{Broadcast, Message, Reply, V2} @serializer V2.JSONSerializer @v2_fastlane_json "[null,null,\"t\",\"e\",{\"m\":1}]" @v2_msg_json "[null,null,\"t\",\"e\",{\"m\":1}]" @client_push << # push 0::size(8), # join_ref_size 2, # ref_size 3, # topic_size 5, # event_size 5, "12", "123", "topic", "event", 101, 102, 103 >> @reply << # reply 1::size(8), # join_ref_size 2, # ref_size 3, # topic_size 5, # status_size 2, "12", "123", "topic", "ok", 101, 102, 103 >> @broadcast << # broadcast 2::size(8), # topic_size 5, # event_size 5, "topic", "event", 101, 102, 103 >> def encode!(serializer, msg) do case serializer.encode!(msg) do {:socket_push, :text, encoded} -> assert is_list(encoded) IO.iodata_to_binary(encoded) {:socket_push, :binary, encoded} -> assert is_binary(encoded) encoded end end def decode!(serializer, msg, opts \\ []) do serializer.decode!(msg, opts) end def fastlane!(serializer, msg) do case serializer.fastlane!(msg) do {:socket_push, :text, encoded} -> assert is_list(encoded) IO.iodata_to_binary(encoded) {:socket_push, :binary, encoded} -> assert is_binary(encoded) encoded end end test "encode!/1 encodes `Phoenix.Socket.Message` as JSON" do msg = %Message{topic: "t", event: "e", payload: %{m: 1}} assert encode!(@serializer, msg) == @v2_msg_json end test "encode!/1 raises when payload is not a map" do msg = %Message{topic: "t", event: "e", payload: "invalid"} assert_raise ArgumentError, fn -> encode!(@serializer, msg) end end test "encode!/1 encodes `Phoenix.Socket.Reply` as JSON" do msg = %Reply{topic: "t", payload: %{m: 1}} encoded = encode!(@serializer, msg) assert Jason.decode!(encoded) == [ nil, nil, "t", "phx_reply", %{"response" => %{"m" => 1}, "status" => nil} ] end test "decode!/2 decodes `Phoenix.Socket.Message` from JSON" do assert %Message{topic: "t", event: "e", payload: %{"m" => 1}} == decode!(@serializer, @v2_msg_json, opcode: :text) end test "fastlane!/1 encodes a broadcast into a message as JSON" do msg = %Broadcast{topic: "t", event: "e", payload: %{m: 1}} assert fastlane!(@serializer, msg) == @v2_fastlane_json end test "fastlane!/1 raises when payload is not a map" do msg = %Broadcast{topic: "t", event: "e", payload: "invalid"} assert_raise ArgumentError, fn -> fastlane!(@serializer, msg) end end describe "binary encode" do test "general pushed message" do push = << # push 0::size(8), # join_ref_size 2, # topic_size 5, # event_size 5, "12", "topic", "event", 101, 102, 103 >> assert encode!(@serializer, %Phoenix.Socket.Message{ join_ref: "12", ref: nil, topic: "topic", event: "event", payload: {:binary, <<101, 102, 103>>} }) == push end test "encode with oversized headers" do assert_raise ArgumentError, ~r/unable to convert topic to binary/, fn -> encode!(@serializer, %Phoenix.Socket.Message{ join_ref: "12", ref: nil, topic: String.duplicate("t", 256), event: "event", payload: {:binary, <<101, 102, 103>>} }) end assert_raise ArgumentError, ~r/unable to convert event to binary/, fn -> encode!(@serializer, %Phoenix.Socket.Message{ join_ref: "12", ref: nil, topic: "topic", event: String.duplicate("e", 256), payload: {:binary, <<101, 102, 103>>} }) end assert_raise ArgumentError, ~r/unable to convert join_ref to binary/, fn -> encode!(@serializer, %Phoenix.Socket.Message{ join_ref: String.duplicate("j", 256), ref: nil, topic: "topic", event: "event", payload: {:binary, <<101, 102, 103>>} }) end end test "reply" do assert encode!(@serializer, %Phoenix.Socket.Reply{ join_ref: "12", ref: "123", topic: "topic", status: :ok, payload: {:binary, <<101, 102, 103>>} }) == @reply end test "reply with oversized headers" do assert_raise ArgumentError, ~r/unable to convert ref to binary/, fn -> encode!(@serializer, %Phoenix.Socket.Reply{ join_ref: "12", ref: String.duplicate("r", 256), topic: "topic", status: :ok, payload: {:binary, <<101, 102, 103>>} }) end end test "fastlane" do assert fastlane!(@serializer, %Phoenix.Socket.Broadcast{ topic: "topic", event: "event", payload: {:binary, <<101, 102, 103>>} }) == @broadcast end test "fastlane with oversized headers" do assert_raise ArgumentError, ~r/unable to convert topic to binary/, fn -> fastlane!(@serializer, %Phoenix.Socket.Broadcast{ topic: String.duplicate("t", 256), event: "event", payload: {:binary, <<101, 102, 103>>} }) end assert_raise ArgumentError, ~r/unable to convert event to binary/, fn -> fastlane!(@serializer, %Phoenix.Socket.Broadcast{ topic: "topic", event: String.duplicate("e", 256), payload: {:binary, <<101, 102, 103>>} }) end end end describe "binary decode" do test "pushed message" do assert decode!(@serializer, @client_push, opcode: :binary) == %Phoenix.Socket.Message{ join_ref: "12", ref: "123", topic: "topic", event: "event", payload: {:binary, <<101, 102, 103>>} } end end end ================================================ FILE: test/phoenix/test/channel_test.exs ================================================ defmodule Phoenix.Test.ChannelTest do use ExUnit.Case, async: true alias Phoenix.Socket alias Phoenix.Socket.{Broadcast, Message} alias __MODULE__.{UserSocket, Endpoint} Application.put_env(:phoenix, Endpoint, pubsub_server: Phoenix.Test.ChannelTest.PubSub, server: false ) defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix socket "/socket", UserSocket end defmodule EmptyChannel do use Phoenix.Channel def join(_, _, socket), do: {:ok, socket} def handle_in(_event, _params, socket) do {:reply, :ok, socket} end end defmodule Channel do use Phoenix.Channel intercept ["stop"] def join("foo:ok", _, socket) do {:ok, socket} end def join("foo:external", _, socket) do :ok = Phoenix.PubSub.subscribe(Phoenix.Test.ChannelTest.PubSub, "external:topic") {:ok, socket} end def join("foo:timeout", _, socket) do Process.flag(:trap_exit, true) {:ok, socket} end def join("foo:socket", _, socket) do socket = assign(socket, :hello, :world) {:ok, socket, socket} end def join("foo:error", %{"error" => reason}, _socket) do {:error, %{reason: reason}} end def join("foo:crash", %{}, _socket) do :unknown end def join("foo:payload", %{"string" => _payload}, socket) do {:ok, socket} end def handle_in("broadcast", broadcast, socket) do broadcast_from!(socket, "broadcast", broadcast) {:noreply, socket} end def handle_in("noreply", %{"req" => arg}, socket) do push(socket, "noreply", %{"resp" => arg}) {:noreply, socket} end def handle_in("reply", %{"req" => arg}, socket) do {:reply, {:ok, %{"resp" => arg}}, socket} end def handle_in("reply", %{}, socket) do {:reply, :ok, socket} end def handle_in("crash", %{}, _socket) do raise "boom!" end def handle_in("async_reply", %{"req" => arg}, socket) do ref = socket_ref(socket) Task.start(fn -> reply(ref, {:ok, %{"async_resp" => arg}}) end) {:noreply, socket} end def handle_in("stop", %{"reason" => stop}, socket) do {:stop, stop, socket} end def handle_in("stop_and_reply", %{"req" => arg}, socket) do {:stop, :shutdown, {:ok, %{"resp" => arg}}, socket} end def handle_in("stop_and_reply", %{}, socket) do {:stop, :shutdown, :ok, socket} end def handle_out("stop", _payload, socket) do {:stop, :shutdown, socket} end def handle_info(%Broadcast{event: event, payload: payload}, socket) do push(socket, event, payload) {:noreply, socket} end def handle_info(:stop, socket) do {:stop, :shutdown, socket} end def handle_info(:push, socket) do push(socket, "info", %{"reason" => "push"}) {:noreply, socket} end def handle_info(:broadcast, socket) do broadcast_from(socket, "info", %{"reason" => "broadcast"}) {:noreply, socket} end def handle_call(:ping, _from, socket) do {:reply, :pong, socket} end def handle_cast({:ping, ref, sender}, socket) do send(sender, {ref, :pong}) {:noreply, socket} end def terminate(_reason, %{topic: "foo:timeout"}) do :timer.sleep(:infinity) end def terminate(reason, socket) do send(socket.transport_pid, {:terminate, reason}) :ok end end defmodule CodeChangeChannel do use Phoenix.Channel def join(_topic, _params, socket), do: {:ok, socket} def code_change(_old, _socket, _extra) do {:error, :cant} end end defmodule UserSocket do use Phoenix.Socket channel "foo:*", Channel, assigns: %{user_socket_assigns: true} def connect(params, socket) do if params["reject"] == true do :error else {:ok, socket} end end def id(_), do: "123" end @endpoint Endpoint @moduletag :capture_log import Phoenix.ChannelTest setup_all do start_supervised! @endpoint start_supervised! {Phoenix.PubSub, name: Phoenix.Test.ChannelTest.PubSub} :ok end defp assert_graceful_exit(pid) do assert_receive {:socket_close, ^pid, _} end ## socket test "socket/1" do assert %Socket{ endpoint: @endpoint, handler: UserSocket, pubsub_server: Phoenix.Test.ChannelTest.PubSub, serializer: Phoenix.ChannelTest.NoopSerializer } = socket(UserSocket) end test "socket/3" do assert %Socket{ id: "user:id", assigns: %{hello: :world}, endpoint: @endpoint, pubsub_server: Phoenix.Test.ChannelTest.PubSub, serializer: Phoenix.ChannelTest.NoopSerializer, handler: UserSocket } = socket(UserSocket, "user:id", %{hello: :world}) end test "socket/4" do pid = self() task = Task.async(fn -> assert %Socket{ id: "user:id", assigns: %{hello: :world}, endpoint: @endpoint, pubsub_server: Phoenix.Test.ChannelTest.PubSub, serializer: Phoenix.ChannelTest.NoopSerializer, handler: UserSocket } = socket(UserSocket, "user:id", %{hello: :world}, test_process: pid) end) Task.await(task) end ## join test "join/3 with success" do assert {:ok, socket, client} = join(socket(UserSocket, "id", original: :assign), Channel, "foo:socket") assert socket.channel == Channel assert socket.endpoint == @endpoint assert socket.pubsub_server == Phoenix.Test.ChannelTest.PubSub assert socket.topic == "foo:socket" assert {Phoenix.ChannelTest, _} = socket.transport assert socket.transport_pid == self() assert socket.serializer == Phoenix.ChannelTest.NoopSerializer assert socket.assigns == %{hello: :world, original: :assign} assert %{socket | joined: true} == client {:links, links} = Process.info(self(), :links) assert client.channel_pid in links {:dictionary, dictionary} = Process.info(client.channel_pid, :dictionary) assert dictionary[:"$callers"] == [self()] end test "join/3 from another process" do socket = socket(UserSocket, "id", original: :assign) assert {:ok, socket, client} = Task.async(fn -> join(socket, Channel, "foo:socket") end) |> Task.await() assert %{socket | joined: true} == client end test "join/3 with error reply" do assert {:error, %{reason: "mybad"}} = join(socket(UserSocket), Channel, "foo:error", %{"error" => "mybad"}) end test "join/3 with crash" do Process.flag(:trap_exit, true) Logger.put_process_level(self(), :none) assert {:error, %{reason: "join crashed"}} = join(socket(UserSocket), Channel, "foo:crash") end ## handle_in test "assert_push with guards" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") push(socket, "noreply", %{"req" => "foo"}) assert_push "noreply", %{"resp" => resp} when is_binary(resp) end test "pushes and receives pushed messages" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "noreply", %{"req" => "foo"}) assert_push "noreply", %{"resp" => "foo"} refute_reply ref, _status end test "pushes and receives replies" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "reply", %{}) assert_reply ref, :ok refute_push _status, _payload ref = push(socket, "reply", %{"req" => "foo"}) assert_reply ref, :ok, %{"resp" => "foo"} end test "works with list data structures" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "reply", %{req: [%{bar: "baz"}, %{bar: "foo"}]}) assert_reply ref, :ok, %{"resp" => [%{"bar" => "baz"}, %{"bar" => "foo"}]} end test "receives async replies" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "async_reply", %{"req" => "foo"}) assert_reply ref, :ok, %{"async_resp" => "foo"} end test "crashed channel propagates exit" do Process.flag(:trap_exit, true) {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") push(socket, "crash", %{}) pid = socket.channel_pid assert_receive {:terminate, _} assert_receive {:EXIT, ^pid, _} refute_receive {:socket_close, _, _} end test "pushes on stop" do Process.flag(:trap_exit, true) {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") push(socket, "stop", %{"reason" => :normal}) pid = socket.channel_pid assert_receive {:terminate, :normal} assert_graceful_exit(pid) # Pushing after stop doesn't crash the client/transport Process.flag(:trap_exit, false) push(socket, "stop", %{"reason" => :normal}) end test "pushes and receives replies on stop" do Process.flag(:trap_exit, true) {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "stop_and_reply", %{}) assert_reply ref, :ok pid = socket.channel_pid assert_receive {:terminate, :shutdown} assert_graceful_exit(pid) {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "stop_and_reply", %{"req" => "foo"}) assert_reply ref, :ok, %{"resp" => "foo"} pid = socket.channel_pid assert_receive {:terminate, :shutdown} assert_graceful_exit(pid) end test "assert_broadcast with guards" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") push(socket, "broadcast", %{"foo" => "bar"}) assert_broadcast "broadcast", %{"foo" => resp} when is_binary(resp) end test "pushes and broadcast messages" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") refute_broadcast "broadcast", _params push(socket, "broadcast", %{"foo" => "bar"}) assert_broadcast "broadcast", %{"foo" => "bar"} end test "connects and joins topics directly" do :error = connect(UserSocket, %{"reject" => true}) {:ok, socket} = connect(UserSocket, %{}) socket = subscribe_and_join!(socket, "foo:ok") push(socket, "broadcast", %{"foo" => "bar"}) assert socket.id == "123" assert_broadcast "broadcast", %{"foo" => "bar"} {:ok, _, socket} = subscribe_and_join(socket, "foo:ok") push(socket, "broadcast", %{"foo" => "bar"}) assert socket.id == "123" assert_broadcast "broadcast", %{"foo" => "bar"} end test "connects and joins topics directly, from another process" do pid = self() task = Task.async(fn -> {:ok, socket} = connect(UserSocket, %{}, test_process: pid) socket = subscribe_and_join!(socket, "foo:ok") push(socket, "broadcast", %{"foo" => "bar"}) assert socket.id == "123" assert_broadcast "broadcast", %{"foo" => "bar"} end) Task.await(task) end test "pushes atom parameter keys as strings" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "reply", %{req: %{parameter: 1}}) assert_reply ref, :ok, %{"resp" => %{"parameter" => 1}} end test "assert_reply with guards" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = push(socket, "reply", %{req: %{parameter: 1}}) assert_reply ref, :ok, %{"resp" => resp} when is_map(resp) end test "pushes structs without modifying them" do {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") date = ~D[2010-04-17] ref = push(socket, "reply", %{req: date}) assert_reply ref, :ok, %{"resp" => ^date} end test "connects with atom parameter keys as strings" do :error = connect(UserSocket, %{reject: true}) end ## handle_out test "push broadcasts by default" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") broadcast_from!(socket, "default", %{"foo" => "bar"}) assert_push "default", %{"foo" => "bar"} end test "push broadcasts by default, outside of test process" do pid = self() task = Task.async(fn -> socket = subscribe_and_join!( socket(UserSocket, "user_id", %{some: :assign}, test_process: pid), Channel, "foo:ok" ) broadcast_from!(socket, "default", %{"foo" => "bar"}) assert_push "default", %{"foo" => "bar"} end) Task.await(task) end test "handles broadcasts and stops" do Process.flag(:trap_exit, true) {:ok, _, socket} = subscribe_and_join(socket(UserSocket), Channel, "foo:ok") broadcast_from!(socket, "stop", %{"foo" => "bar"}) pid = socket.channel_pid assert_receive {:terminate, :shutdown} assert_graceful_exit(pid) end ## handle_info test "handles messages and stops" do Process.flag(:trap_exit, true) socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") pid = socket.channel_pid send(pid, :stop) assert_receive {:terminate, :shutdown} assert_graceful_exit(pid) end test "handles messages and pushes" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") send(socket.channel_pid, :push) assert_push "info", %{"reason" => "push"} end test "handles messages and broadcasts" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") send(socket.channel_pid, :broadcast) assert_broadcast "info", %{"reason" => "broadcast"} end ## handle_call/cast test "handles calls" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") assert GenServer.call(socket.channel_pid, :ping) == :pong end test "handles casts" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:ok") ref = make_ref() :ok = GenServer.cast(socket.channel_pid, {:ping, ref, self()}) assert_receive {^ref, :pong} end ## terminate test "leaves the channel" do Process.flag(:trap_exit, true) {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") ref = leave(socket) assert_reply ref, :ok pid = socket.channel_pid assert_receive {:terminate, {:shutdown, :left}} assert_graceful_exit(pid) # Leaving again doesn't crash _ = leave(socket) end test "closes the channel" do Process.flag(:trap_exit, true) {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:ok") close(socket) pid = socket.channel_pid assert_receive {:terminate, {:shutdown, :closed}} assert_receive {:EXIT, ^pid, {:shutdown, :closed}} # Closing again doesn't crash _ = close(socket) end test "kills the channel when we reach timeout on close" do Process.flag(:trap_exit, true) {:ok, _, socket} = join(socket(UserSocket), Channel, "foo:timeout") close(socket, 0) pid = socket.channel_pid assert_receive {:EXIT, ^pid, :killed} refute_received {:terminate, :killed} # Closing again doesn't crash _ = close(socket) end test "code_change/3 proxies to channel" do socket = %Socket{channel: Channel} assert Phoenix.Channel.Server.code_change(:old, socket, :extra) == {:ok, socket} end test "code_change/3 is overridable" do socket = %Socket{channel: CodeChangeChannel} assert Phoenix.Channel.Server.code_change(:old, socket, :extra) == {:error, :cant} end test "external subscriptions" do socket = subscribe_and_join!(socket(UserSocket), Channel, "foo:external") socket.endpoint.broadcast!("external:topic", "external_event", %{one: 1}) assert_receive %Message{topic: "foo:external", event: "external_event", payload: %{one: 1}} end test "warns on unhandled handle_info/2 messages" do socket = subscribe_and_join!(socket(UserSocket), EmptyChannel, "topic") assert ExUnit.CaptureLog.capture_log(fn -> send(socket.channel_pid, :unhandled) ref = push(socket, "hello", %{}) assert_reply ref, :ok end) =~ "received unexpected message in handle_info/2: :unhandled" end test "subscribes to socket.id and receives disconnects" do {:ok, socket} = connect(UserSocket, %{}) socket.endpoint.broadcast!(socket.id, "disconnect", %{}) assert_broadcast "disconnect", %{} end test "supports static assigns in user socket channel definition" do {:ok, socket} = connect(UserSocket, %{}) socket = subscribe_and_join!(socket, "foo:ok") assert socket.assigns.user_socket_assigns end test "converts payload on join to string keyed" do {:ok, socket} = connect(UserSocket, %{}) assert {:ok, _, _socket} = subscribe_and_join(socket, "foo:payload", %{string: nil}) end end ================================================ FILE: test/phoenix/test/conn_test.exs ================================================ defmodule Phoenix.Test.ConnTest.CatchAll do defmodule ConnError do defexception message: "hello", plug_status: 500 end def init(opts), do: opts def call(conn, :stat) do case conn.params["action"] do "conn_404" -> raise ConnError, plug_status: 404 "conn_400" -> raise ConnError, plug_status: 400 "runtime" -> raise RuntimeError "send_400" -> Plug.Conn.send_resp(conn, 400, "") end end def call(conn, _opts), do: Plug.Conn.assign(conn, :catch_all, true) end alias Phoenix.Test.ConnTest.CatchAll defmodule Phoenix.Test.ConnTest.RedirRouter do use Phoenix.Router get "/", CatchAll, :foo get "/posts/:id", CatchAll, :some_action end defmodule Phoenix.Test.ConnTest.Router do use Phoenix.Router pipeline :browser do plug :put_bypass, :browser end pipeline :api do plug :put_bypass, :api end scope "/" do pipe_through :browser get "/stat", CatchAll, :stat, private: %{route: :stat} forward "/redir", Phoenix.Test.ConnTest.RedirRouter forward "/", CatchAll end def put_bypass(conn, pipeline) do bypassed = (conn.assigns[:bypassed] || []) ++ [pipeline] Plug.Conn.assign(conn, :bypassed, bypassed) end end defmodule Phoenix.Test.ConnTest do use ExUnit.Case, async: true import Plug.Conn import Phoenix.ConnTest alias Phoenix.Test.ConnTest.{Router, RedirRouter} @moduletag :capture_log Application.put_env(:phoenix, Phoenix.Test.ConnTest.Endpoint, []) defmodule Endpoint do use Phoenix.Endpoint, otp_app: :phoenix def init(opts), do: opts def call(conn, :set), do: resp(conn, 200, "ok") def call(conn, opts) do put_in(super(conn, opts).private[:endpoint], opts) |> Router.call(Router.init([])) end end @endpoint Endpoint setup_all do Logger.put_process_level(self(), :none) Endpoint.start_link() :ok end test "build_conn/0 returns a new connection" do conn = build_conn() assert conn.method == "GET" assert conn.path_info == [] assert conn.private.plug_skip_csrf_protection assert conn.private.phoenix_recycled end test "build_conn/2 returns a new connection" do conn = build_conn(:post, "/hello") assert conn.method == "POST" assert conn.path_info == ["hello"] assert conn.private.plug_skip_csrf_protection assert conn.private.phoenix_recycled end test "dispatch/5 with path" do conn = post build_conn(), "/hello", foo: "bar" assert conn.method == "POST" assert conn.path_info == ["hello"] assert conn.params == %{"foo" => "bar"} assert conn.private.endpoint == [] refute conn.private.phoenix_recycled end test "dispatch/5 with action" do conn = post build_conn(), :hello, %{foo: "bar"} assert conn.method == "POST" assert conn.path_info == [] assert conn.params == %{"foo" => "bar"} assert conn.private.endpoint == :hello refute conn.private.phoenix_recycled end test "dispatch/5 with binary body" do assert_raise ArgumentError, fn -> post build_conn(), :hello, "foo=bar" end conn = build_conn() |> put_req_header("content-type", "application/json") |> post(:hello, "[1, 2, 3]") |> Plug.Parsers.call( Plug.Parsers.init(parsers: [:json], json_decoder: Phoenix.json_library()) ) assert conn.method == "POST" assert conn.path_info == [] assert conn.params == %{"_json" => [1, 2, 3]} end test "dispatch/5 with recycling" do conn = build_conn() |> put_req_header("hello", "world") |> post(:hello) assert get_req_header(conn, "hello") == ["world"] conn = conn |> put_req_header("hello", "skipped") |> post(:hello) assert get_req_header(conn, "hello") == [] conn = conn |> recycle() |> put_req_header("hello", "world") |> post(:hello) assert get_req_header(conn, "hello") == ["world"] end test "dispatch/5 with :set state automatically sends" do conn = get(build_conn(), :set) assert conn.state == :sent assert conn.status == 200 assert conn.resp_body == "ok" refute conn.private.phoenix_recycled end describe "recycle/1" do test "relevant request headers are persisted" do conn = build_conn() |> get("/") |> put_req_header("accept", "text/html") |> put_req_header("accept-language", "ja") |> put_req_header("authorization", "Bearer mytoken") |> put_req_header("hello", "world") conn = conn |> recycle() assert get_req_header(conn, "accept") == ["text/html"] assert get_req_header(conn, "accept-language") == ["ja"] assert get_req_header(conn, "authorization") == ["Bearer mytoken"] assert get_req_header(conn, "hello") == [] end test "host is persisted" do conn = build_conn(:get, "http://localhost/", nil) |> recycle() assert conn.host == "localhost" end test "remote_ip is persisted" do conn = %{build_conn(:get, "http://localhost/", nil) | remote_ip: {192, 168, 0, 1}} |> recycle() assert conn.remote_ip == {192, 168, 0, 1} end test "cookies are persisted" do conn = build_conn() |> get("/") |> put_req_cookie("req_cookie", "req_cookie") |> put_req_cookie("del_cookie", "del_cookie") |> put_req_cookie("over_cookie", "pre_cookie") |> put_resp_cookie("over_cookie", "pos_cookie") |> put_resp_cookie("resp_cookie", "resp_cookie") |> delete_resp_cookie("del_cookie") conn = conn |> recycle() |> fetch_cookies() assert conn.cookies == %{ "req_cookie" => "req_cookie", "over_cookie" => "pos_cookie", "resp_cookie" => "resp_cookie" } end test "peer data is persisted" do peer_data = %{ address: {127, 0, 0, 1}, port: 111_317, ssl_cert: <<1, 2, 3, 4>> } conn = build_conn() |> Plug.Test.put_peer_data(peer_data) conn = conn |> recycle() assert Plug.Conn.get_peer_data(conn) == peer_data end end describe "recycle/2" do test "custom request headers are persisted" do conn = build_conn() |> get("/") |> put_req_header("accept", "text/html") |> put_req_header("hello", "world") |> put_req_header("foo", "bar") conn = conn |> recycle(~w(hello accept)) assert get_req_header(conn, "accept") == ["text/html"] assert get_req_header(conn, "hello") == ["world"] assert get_req_header(conn, "foo") == [] end end test "ensure_recycled/1" do conn = build_conn() |> put_req_header("hello", "world") |> ensure_recycled() assert get_req_header(conn, "hello") == ["world"] conn = put_in(conn.private.phoenix_recycled, false) |> ensure_recycled() assert get_req_header(conn, "hello") == [] end test "put_req_header/3 and delete_req_header/3" do conn = build_conn(:get, "/") assert get_req_header(conn, "foo") == [] conn = put_req_header(conn, "foo", "bar") assert get_req_header(conn, "foo") == ["bar"] conn = put_req_header(conn, "foo", "baz") assert get_req_header(conn, "foo") == ["baz"] conn = delete_req_header(conn, "foo") assert get_req_header(conn, "foo") == [] end test "put_req_cookie/3 and delete_req_cookie/2" do conn = build_conn(:get, "/") assert get_req_header(conn, "cookie") == [] conn = conn |> put_req_cookie("foo", "bar") assert get_req_header(conn, "cookie") == ["foo=bar"] conn = conn |> delete_req_cookie("foo") assert get_req_header(conn, "cookie") == [] end test "response/2" do conn = build_conn(:get, "/") assert conn |> resp(200, "ok") |> response(200) == "ok" assert conn |> send_resp(200, "ok") |> response(200) == "ok" assert conn |> send_resp(200, "ok") |> response(:ok) == "ok" assert_raise RuntimeError, ~r"expected connection to have a response but no response was set/sent", fn -> build_conn(:get, "/") |> response(200) end assert_raise RuntimeError, "expected response with status 200, got: 404, with body:\n\"oops\"", fn -> build_conn(:get, "/") |> resp(404, "oops") |> response(200) end assert_raise RuntimeError, "expected response with status 200, got: 404, with body:\n<<192>>", fn -> build_conn(:get, "/") |> resp(404, <<192>>) |> response(200) end end test "html_response/2" do assert build_conn(:get, "/") |> put_resp_content_type("text/html") |> resp(200, "ok") |> html_response(:ok) == "ok" assert_raise RuntimeError, "no content-type was set, expected a html response", fn -> build_conn(:get, "/") |> resp(200, "ok") |> html_response(200) end end test "json_response/2" do assert build_conn(:get, "/") |> put_resp_content_type("application/json") |> resp(200, "{}") |> json_response(:ok) == %{} assert build_conn(:get, "/") |> put_resp_content_type("application/vnd.api+json") |> resp(200, "{}") |> json_response(:ok) == %{} assert build_conn(:get, "/") |> put_resp_content_type("application/vnd.collection+json") |> resp(200, "{}") |> json_response(:ok) == %{} assert build_conn(:get, "/") |> put_resp_content_type("application/vnd.hal+json") |> resp(200, "{}") |> json_response(:ok) == %{} assert build_conn(:get, "/") |> put_resp_content_type("application/ld+json") |> resp(200, "{}") |> json_response(:ok) == %{} assert_raise RuntimeError, "no content-type was set, expected a json response", fn -> build_conn(:get, "/") |> resp(200, "ok") |> json_response(200) end assert_raise Jason.DecodeError, "unexpected byte at position 0: 0x6F (\"o\")", fn -> build_conn(:get, "/") |> put_resp_content_type("application/json") |> resp(200, "ok") |> json_response(200) end assert_raise Jason.DecodeError, ~r/unexpected end of input at position 0/, fn -> build_conn(:get, "/") |> put_resp_content_type("application/json") |> resp(200, "") |> json_response(200) end assert_raise RuntimeError, ~s(expected response with status 200, got: 400, with body:\n) <> inspect(~s({"error": "oh oh"})), fn -> build_conn(:get, "/") |> put_resp_content_type("application/json") |> resp(400, ~s({"error": "oh oh"})) |> json_response(200) end end test "text_response/2" do assert build_conn(:get, "/") |> put_resp_content_type("text/plain") |> resp(200, "ok") |> text_response(:ok) == "ok" assert_raise RuntimeError, "no content-type was set, expected a text response", fn -> build_conn(:get, "/") |> resp(200, "ok") |> text_response(200) end end test "response_content_type/2" do conn = build_conn(:get, "/") assert put_resp_content_type(conn, "text/html") |> response_content_type(:html) == "text/html; charset=utf-8" assert put_resp_content_type(conn, "text/plain") |> response_content_type(:text) == "text/plain; charset=utf-8" assert put_resp_content_type(conn, "application/json") |> response_content_type(:json) == "application/json; charset=utf-8" assert_raise RuntimeError, "no content-type was set, expected a html response", fn -> conn |> response_content_type(:html) end assert_raise RuntimeError, "expected content-type for html, got: \"text/plain; charset=utf-8\"", fn -> put_resp_content_type(conn, "text/plain") |> response_content_type(:html) end end test "redirected_to/1" do conn = build_conn(:get, "/") |> put_resp_header("location", "new location") |> send_resp(302, "foo") assert redirected_to(conn) == "new location" end test "redirected_to/2" do Enum.each(300..308, fn status -> conn = build_conn(:get, "/") |> put_resp_header("location", "new location") |> send_resp(status, "foo") assert redirected_to(conn, status) == "new location" end) end test "redirected_to/2 with status atom" do conn = build_conn(:get, "/") |> put_resp_header("location", "new location") |> send_resp(301, "foo") assert redirected_to(conn, :moved_permanently) == "new location" end test "redirected_to/2 without header" do assert_raise RuntimeError, "no location header was set on redirected_to", fn -> assert build_conn(:get, "/") |> send_resp(302, "ok") |> redirected_to() end end test "redirected_to/2 without redirection" do assert_raise RuntimeError, "expected redirection with status 302, got: 200", fn -> build_conn(:get, "/") |> put_resp_header("location", "new location") |> send_resp(200, "ok") |> redirected_to() end end test "redirected_to/2 without response" do assert_raise RuntimeError, ~r"expected connection to have redirected but no response was set/sent", fn -> build_conn(:get, "/") |> redirected_to() end end describe "redirected_params/2" do test "with matching route" do conn = build_conn(:get, "/") |> RedirRouter.call(RedirRouter.init([])) |> put_resp_header("location", "/posts/123") |> send_resp(302, "foo") assert redirected_params(conn) == %{id: "123"} end test "with matching forwarded route" do conn = build_conn(:get, "/redir") |> Router.call(Router.init([])) |> put_resp_header("location", "/redir/posts/123") |> send_resp(302, "foo") assert redirected_params(conn) == %{id: "123"} end test "raises Phoenix.Router.NoRouteError for unmatched location" do conn = build_conn(:get, "/") |> RedirRouter.call(RedirRouter.init([])) |> put_resp_header("location", "/unmatched") |> send_resp(302, "foo") assert_raise Phoenix.Router.NoRouteError, fn -> redirected_params(conn) end end test "without redirection" do assert_raise RuntimeError, "expected redirection with status 302, got: 200", fn -> build_conn(:get, "/") |> RedirRouter.call(RedirRouter.init([])) |> put_resp_header("location", "new location") |> send_resp(200, "ok") |> redirected_params() end end test "with custom status code" do Enum.each(300..308, fn status -> conn = build_conn(:get, "/") |> RedirRouter.call(RedirRouter.init([])) |> put_resp_header("location", "/posts/123") |> send_resp(status, "foo") assert redirected_params(conn, status) == %{id: "123"} end) end end describe "path_params/1" do test "with matching route" do conn = RedirRouter.call(build_conn(:get, "/"), RedirRouter.init([])) assert path_params(conn, "/posts/123") == %{id: "123"} end test "raises Phoenix.Router.NoRouteError for unmatched location" do conn = RedirRouter.call(build_conn(:get, "/"), RedirRouter.init([])) assert_raise Phoenix.Router.NoRouteError, fn -> path_params(conn, "/unmatched") end end end test "bypass_through/3 bypasses route match and invokes pipeline" do conn = get(build_conn(), "/") assert conn.assigns[:catch_all] conn = build_conn() |> bypass_through(Router, :browser) |> get("/stat") assert conn.assigns[:bypassed] == [:browser] assert conn.private[:route] == :stat refute conn.assigns[:catch_all] conn = build_conn() |> bypass_through(Router, [:api]) |> get("/stat") assert conn.assigns[:bypassed] == [:api] assert conn.private[:route] == :stat refute conn.assigns[:catch_all] conn = build_conn() |> bypass_through(Router, [:browser, :api]) |> get("/stat") assert conn.assigns[:bypassed] == [:browser, :api] assert conn.private[:route] == :stat refute conn.assigns[:catch_all] end test "bypass_through/3 with empty pipeline" do conn = build_conn() |> bypass_through(Router, []) |> get("/stat") refute conn.assigns[:bypassed] assert conn.private[:route] == :stat refute conn.assigns[:catch_all] end test "bypass_through/2 with route pipeline" do conn = build_conn() |> bypass_through(Router) |> get("/stat") assert conn.assigns[:bypassed] == [:browser] assert conn.private[:route] == :stat refute conn.assigns[:catch_all] end test "bypass_through/1 without router" do conn = build_conn() |> bypass_through() |> get("/stat") refute conn.assigns[:bypassed] assert conn.private[:route] == :stat refute conn.assigns[:catch_all] end test "assert_error_sent/2 with expected error response" do response = assert_error_sent :not_found, fn -> get(build_conn(), "/stat", action: "conn_404") end assert {404, [_h | _t], "404.html from Phoenix.ErrorView"} = response response = assert_error_sent 400, fn -> get(build_conn(), "/stat", action: "conn_400") end assert {400, [_h | _t], "400.html from Phoenix.ErrorView"} = response end test "assert_error_sent/2 with status mismatch assertion" do assert_raise ExUnit.AssertionError, ~r/expected error to be sent as 400 status, but got 500 from.*RuntimeError/s, fn -> assert_error_sent 400, fn -> get(build_conn(), "/stat", action: "runtime") end end end test "assert_error_sent/2 with no error" do assert_raise ExUnit.AssertionError, ~r/expected error to be sent as 404 status, but no error happened/, fn -> assert_error_sent 404, fn -> get(build_conn(), "/") end end end test "assert_error_sent/2 with error but no response" do assert_raise ExUnit.AssertionError, ~r/expected error to be sent as 404 status, but got an error with no response from.*RuntimeError/s, fn -> assert_error_sent 404, fn -> raise "oops" end end end test "assert_error_sent/2 with response but no error" do assert_raise ExUnit.AssertionError, ~r/expected error to be sent as 400 status, but response sent 400 without error/, fn -> assert_error_sent :bad_request, fn -> get(build_conn(), "/stat", action: "send_400") end end end for method <- [:get, :post, :put, :delete] do @method method test "#{method} helper raises ArgumentError for mismatched conn" do assert_raise ArgumentError, ~r/expected first argument to #{@method} to be/, fn -> unquote(@method)("/foo/bar", %{baz: "baz"}) end end end end ================================================ FILE: test/phoenix/token_test.exs ================================================ defmodule Phoenix.TokenTest do use ExUnit.Case, async: true alias Phoenix.Token setup do Logger.put_process_level(self(), :none) :ok end defstruct [:endpoint] defmodule TokenEndpoint do def config(:secret_key_base), do: "abc123" end describe "sign and verify" do test "token with string" do id = 1 key = String.duplicate("abc123", 5) token = Token.sign(key, "id", id) assert Token.verify(key, "id", token) == {:ok, id} end test "token with connection" do id = 1 token = Token.sign(conn(), "id", id) assert Token.verify(conn(), "id", token) == {:ok, id} end test "token with socket" do id = 1 token = Token.sign(socket(), "id", id) assert Token.verify(socket(), "id", token) == {:ok, id} id = 1 token = Token.sign(%__MODULE__{endpoint: TokenEndpoint}, "id", id) assert Token.verify(%__MODULE__{endpoint: TokenEndpoint}, "id", token) == {:ok, id} end test "fails on missing token" do assert Token.verify(TokenEndpoint, "id", nil) == {:error, :missing} end test "fails on invalid token" do token = Token.sign(TokenEndpoint, "id", 1) assert Token.verify(TokenEndpoint, "id", "garbage") == {:error, :invalid} assert Token.verify(TokenEndpoint, "not_id", token) == {:error, :invalid} end test "supports max age in seconds" do token = Token.sign(conn(), "id", 1) assert Token.verify(conn(), "id", token, max_age: 1000) == {:ok, 1} assert Token.verify(conn(), "id", token, max_age: -1000) == {:error, :expired} assert Token.verify(conn(), "id", token, max_age: 100) == {:ok, 1} assert Token.verify(conn(), "id", token, max_age: -100) == {:error, :expired} assert Token.verify(conn(), "id", token, max_age: 0) == {:error, :expired} token = Token.sign(conn(), "id", 1) assert Token.verify(conn(), "id", token, max_age: 0.1) == {:ok, 1} :timer.sleep(150) assert Token.verify(conn(), "id", token, max_age: 0.1) == {:error, :expired} end test "supports :infinity for max age" do token = Token.sign(conn(), "id", 1) assert Token.verify(conn(), "id", token, max_age: :infinity) == {:ok, 1} end test "supports signed_at in seconds" do seconds_in_day = 24 * 60 * 60 day_ago_seconds = System.system_time(:second) - seconds_in_day token = Token.sign(conn(), "id", 1, signed_at: day_ago_seconds) assert Token.verify(conn(), "id", token, max_age: seconds_in_day + 1) == {:ok, 1} assert Token.verify(conn(), "id", token, max_age: seconds_in_day - 1) == {:error, :expired} end test "passes key_iterations options to key generator" do signed1 = Token.sign(conn(), "id", 1, signed_at: 0, key_iterations: 1) signed2 = Token.sign(conn(), "id", 1, signed_at: 0, key_iterations: 2) assert signed1 != signed2 end test "passes key_digest options to key generator" do signed1 = Token.sign(conn(), "id", 1, signed_at: 0, key_digest: :sha256) signed2 = Token.sign(conn(), "id", 1, signed_at: 0, key_digest: :sha512) assert signed1 != signed2 end test "key defaults" do signed1 = Token.sign(conn(), "id", 1, signed_at: 0) signed2 = Token.sign(conn(), "id", 1, signed_at: 0, key_length: 32, key_digest: :sha256, key_iterations: 1000 ) assert signed1 == signed2 end end describe "encrypt and decrypt" do test "token with string" do id = 1 key = String.duplicate("abc123", 5) token = Token.encrypt(key, "secret", id) assert Token.decrypt(key, "secret", token) == {:ok, id} end test "token with connection" do id = 1 token = Token.encrypt(conn(), "secret", id) assert Token.decrypt(conn(), "secret", token) == {:ok, id} end test "token with socket" do id = 1 token = Token.encrypt(socket(), "secret", id) assert Token.decrypt(socket(), "secret", token) == {:ok, id} end test "fails on missing token" do assert Token.decrypt(TokenEndpoint, "secret", nil) == {:error, :missing} end test "fails on invalid token" do token = Token.encrypt(TokenEndpoint, "secret", 1) assert Token.decrypt(TokenEndpoint, "secret", "garbage") == {:error, :invalid} assert Token.decrypt(TokenEndpoint, "not_secret", token) == {:error, :invalid} end test "supports max age in seconds" do token = Token.encrypt(conn(), "secret", 1) assert Token.decrypt(conn(), "secret", token, max_age: 1000) == {:ok, 1} assert Token.decrypt(conn(), "secret", token, max_age: -1000) == {:error, :expired} assert Token.decrypt(conn(), "secret", token, max_age: 100) == {:ok, 1} assert Token.decrypt(conn(), "secret", token, max_age: -100) == {:error, :expired} assert Token.decrypt(conn(), "secret", token, max_age: 0) == {:error, :expired} token = Token.encrypt(conn(), "secret", 1) assert Token.decrypt(conn(), "secret", token, max_age: 0.1) == {:ok, 1} :timer.sleep(150) assert Token.decrypt(conn(), "secret", token, max_age: 0.1) == {:error, :expired} end test "supports :infinity for max age" do token = Token.encrypt(conn(), "secret", 1) assert Token.decrypt(conn(), "secret", token, max_age: :infinity) == {:ok, 1} end test "supports signed_at in seconds" do seconds_in_day = 24 * 60 * 60 day_ago_seconds = System.system_time(:second) - seconds_in_day token = Token.encrypt(conn(), "secret", 1, signed_at: day_ago_seconds) assert Token.decrypt(conn(), "secret", token, max_age: seconds_in_day + 1) == {:ok, 1} assert Token.decrypt(conn(), "secret", token, max_age: seconds_in_day - 1) == {:error, :expired} end test "passes key_iterations options to key generator" do signed1 = Token.encrypt(conn(), "secret", 1, signed_at: 0, key_iterations: 1) signed2 = Token.encrypt(conn(), "secret", 1, signed_at: 0, key_iterations: 2) assert signed1 != signed2 end test "passes key_digest options to key generator" do signed1 = Token.encrypt(conn(), "secret", 1, signed_at: 0, key_digest: :sha256) signed2 = Token.encrypt(conn(), "secret", 1, signed_at: 0, key_digest: :sha512) assert signed1 != signed2 end end defp socket() do %Phoenix.Socket{endpoint: TokenEndpoint} end defp conn() do %Plug.Conn{} |> Plug.Conn.put_private(:phoenix_endpoint, TokenEndpoint) end end ================================================ FILE: test/phoenix/verified_routes_test.exs ================================================ modules = [ Phoenix.VerifiedRoutesTest.PostController, Phoenix.VerifiedRoutesTest.UserController ] for module <- modules do defmodule module do def init(opts), do: opts def call(conn, _opts), do: conn end end defmodule PlugRouterWithVerifiedRoutes do use Plug.Router @behaviour Phoenix.VerifiedRoutes get "/foo" do send_resp(conn, 200, "ok") end @impl Phoenix.VerifiedRoutes def formatted_routes(_plug_opts) do [ %{verb: "GET", path: "/foo", label: "Hello"} ] end @impl Phoenix.VerifiedRoutes def verified_route?(_plug_opts, path) do path == ["foo"] end end defmodule Phoenix.VerifiedRoutesTest do use ExUnit.Case, async: true import Plug.Test @derive {Phoenix.Param, key: :slug} defstruct [:id, :slug] defmodule AdminRouter do use Phoenix.Router get "/dashboard", Phoenix.VerifiedRoutesTest.UserController, :index end defmodule Router do use Phoenix.Router alias Phoenix.VerifiedRoutesTest.{PostController, UserController} get "/posts/top", PostController, :top get "/posts/bottom/:order/:count", PostController, :bottom get "/posts/:id", PostController, :show get "/posts/:id/info", PostController, :show get "/posts/file/*file", PostController, :file get "/posts/skip", PostController, :skip get "/should-warn/*all", PostController, :all, warn_on_verify: true get "/ø", PostController, :unicode scope "/", host: "users." do post "/host_users/:id/info", UserController, :create end scope "/admin/new" do resources "/messages", PostController end get "/", PostController, :root forward "/router_forward", AdminRouter forward "/plug_forward", UserController scope "/:locale" do get "/foo", PostController, :show get "/bar", PostController, :show end end defmodule CatchAllWarningRouter do use Phoenix.Router alias Phoenix.VerifiedRoutesTest.PostController get "/", PostController, :root get "/*path", PostController, :root, warn_on_verify: true end defmodule ForwardedRouter do use Phoenix.Router forward "/", PlugRouterWithVerifiedRoutes end # Emulate regular endpoint functions defmodule Endpoint do def url, do: "https://example.com" def static_url, do: "https://static.example.com" def path(path), do: path def static_path(path), do: path def static_integrity(_path), do: nil end defmodule ScriptName do def url, do: "https://example.com" def static_url, do: "https://static.example.com" def path(path), do: "/api" <> path def static_path(path), do: "/api" <> path end defmodule StaticPath do def url, do: "https://example.com" def static_url, do: "https://example.com" def path(path), do: path def static_path(path), do: "/static" <> path def static_integrity(_path), do: nil end defp conn_with_endpoint(endpoint \\ Endpoint) do conn(:get, "/") |> Plug.Conn.put_private(:phoenix_endpoint, endpoint) end defp socket_with_endpoint(endpoint \\ Endpoint), do: %Phoenix.Socket{endpoint: endpoint} def conn_with_script_name(script_name \\ ~w(api)) do conn = Plug.Conn.put_private(conn(:get, "/"), :phoenix_endpoint, ScriptName) put_in(conn.script_name, script_name) end defp uri_with_script_name do %URI{scheme: "https", host: "example.com", port: 123, path: "/api"} end use Phoenix.VerifiedRoutes, statics: ~w(images), endpoint: Endpoint, router: Router test "~p with static string" do assert ~p"/posts/1" == "/posts/1" assert ~p"/posts/1?foo=bar" == "/posts/1?foo=bar" end test "~p with dynamic string uses Phoenix.Param" do struct = %__MODULE__{id: 123, slug: "post-123"} assert ~p"/posts/#{struct}" == "/posts/post-123" assert ~p"/posts/#{123}" == "/posts/123" assert ~p|/posts/#{"a b"}| == "/posts/a%20b" end test "~p with static and dynamic string and query params" do struct = %__MODULE__{id: 123, slug: "post-123"} # static segments assert ~p"/posts/1?foo=bar" == "/posts/1?foo=bar" assert ~p"/posts/bottom/asc/10?foo=bar" == "/posts/bottom/asc/10?foo=bar" assert path(conn_with_endpoint(), ~p"/posts/1?foo=bar") == "/posts/1?foo=bar" assert path(@endpoint, @router, ~p"/posts/1?foo=bar") == "/posts/1?foo=bar" assert path(conn_with_endpoint(), ~p"/posts/bottom/asc/10?foo=bar") == "/posts/bottom/asc/10?foo=bar" assert path(@endpoint, @router, ~p"/posts/bottom/asc/10?foo=bar") == "/posts/bottom/asc/10?foo=bar" # dynamic segments assert ~p"/posts/#{struct}?#{[page: 1, spaced: "a b"]}" == "/posts/post-123?page=1&spaced=a+b" assert ~p"/posts/#{struct}?#{[page: 1, spaced: "a b"]}" == "/posts/post-123?page=1&spaced=a+b" id = 123 dir = "asc" assert ~p"/posts/#{id}?foo=bar" == "/posts/123?foo=bar" assert ~p"/posts/post-#{id}?foo=bar" == "/posts/post-123?foo=bar" assert path(conn_with_endpoint(), ~p"/posts/#{id}?foo=bar") == "/posts/123?foo=bar" assert path(@endpoint, @router, ~p"/posts/#{id}?foo=bar") == "/posts/123?foo=bar" assert path(conn_with_endpoint(), ~p"/posts/bottom/#{dir}/#{id}?foo=bar") == "/posts/bottom/asc/123?foo=bar" assert path(@endpoint, @router, ~p"/posts/bottom/#{dir}/#{id}?foo=bar") == "/posts/bottom/asc/123?foo=bar" # dynamic query params assert ~p"/posts/1?other_post=#{id}" == "/posts/1?other_post=123" assert ~p"/posts/1?other_post=#{struct}" == "/posts/1?other_post=post-123" end test "~p with dynamic string and static query params" do struct = %__MODULE__{id: 123, slug: "post-123"} assert ~p"/posts/#{struct}?foo=bar" == "/posts/post-123?foo=bar" end test "~p with scoped host" do assert ~p"/host_users/1/info" == "/host_users/1/info" end test "~p on splat segments" do assert ~p|/posts/file/#{1}/#{"2.jpg"}| == "/posts/file/1/2.jpg" location = ["folder", "file.jpg"] assert ~p|/posts/file/#{location}| == "/posts/file/folder/file.jpg" end test "~p URI encodes interpolated segments and query params" do assert ~p"/posts/my path?#{[foo: "my param"]}" == "/posts/my%20path?foo=my+param" slug = "my path" assert ~p"/posts/#{slug}?#{[foo: "my param"]}" == "/posts/my%20path?foo=my+param" end test "~p with empty query string drops ?" do assert ~p"/posts/5?#{%{}}" == "/posts/5" end test "~p with hash" do assert ~p"/posts/123/info#bar" == "/posts/123/info#bar" warnings = ExUnit.CaptureIO.capture_io(:stderr, fn -> defmodule Hash do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test, do: ~p"/posts/123/info#bar" end end) refute warnings =~ "no route path" after :code.purge(__MODULE__.Hash) :code.delete(__MODULE__.Hash) end test ":path_prefixes" do defmodule PathPrefixes do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router), path_prefixes: [{__MODULE__, :locale, [{1, 2, 3}]}], statics: ["images"] def locale({1, 2, 3}), do: "en" def foo, do: ~p"/foo" def bar, do: ~p"/bar" def images_baz, do: ~p"/images/baz" end assert PathPrefixes.foo() == "/en/foo" assert PathPrefixes.bar() == "/en/bar" assert PathPrefixes.images_baz() == "/images/baz" end test "unverified_path" do assert unverified_path(conn_with_script_name(), @router, "/posts") == "/api/posts" assert unverified_path(@endpoint, @router, "/posts") == "/posts" assert unverified_path(@endpoint, @router, "/posts", %{}) == "/posts" assert unverified_path(@endpoint, @router, "/posts", a: "b") == "/posts?a=b" end test "unverified_url" do assert unverified_url(conn_with_script_name(), "/posts") == "https://example.com/posts" assert unverified_url(@endpoint, "/posts") == "https://example.com/posts" assert unverified_url(@endpoint, "/posts", %{}) == "https://example.com/posts" assert unverified_url(@endpoint, "/posts", a: "b") == "https://example.com/posts?a=b" end test "~p raises on leftover sigil" do assert_raise ArgumentError, "~p does not support modifiers after closing, got: foo", fn -> defmodule LeftOver do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test, do: ~p"/posts/1"foo end end after :code.purge(__MODULE__.LeftOver) :code.delete(__MODULE__.LeftOver) end test "~p raises on dynamic interpolation" do msg = ~S|a dynamic ~p interpolation must follow a static segment, got: "/posts/#{1}#{2}"| assert_raise ArgumentError, msg, fn -> defmodule DynamicDynamic do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test, do: ~p"/posts/#{1}#{2}" end end after :code.purge(__MODULE__.DynamicDynamic) :code.delete(__MODULE__.DynamicDynamic) end test "~p raises when not prefixed by /" do assert_raise ArgumentError, ~s|paths must begin with /, got: "posts/1"|, fn -> defmodule SigilPPrefix do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test, do: ~p"posts/1" end end after :code.purge(__MODULE__.SigilPPrefix) :code.delete(__MODULE__.SigilPPrefix) end test "path arities" do assert path(Endpoint, ~p"/posts/1") == "/posts/1" assert path(conn_with_endpoint(), ~p"/posts/1") == "/posts/1" assert path(conn_with_script_name(), ~p"/posts/1") == "/api/posts/1" end test "url arities" do assert url(~p"/posts/1") == "https://example.com/posts/1" assert url(~p"/posts/#{123}") == "https://example.com/posts/123" assert url(Endpoint, ~p"/posts/1") == "https://example.com/posts/1" assert url(conn_with_endpoint(), ~p"/posts/1") == "https://example.com/posts/1" assert url(conn_with_script_name(), ~p"/posts/1") == "https://example.com/api/posts/1" assert url(Endpoint, Router, ~p"/posts/1") == "https://example.com/posts/1" assert url(conn_with_endpoint(), Router, ~p"/posts/1") == "https://example.com/posts/1" assert url(conn_with_script_name(), Router, ~p"/posts/1") == "https://example.com/api/posts/1" end test "path raises when non ~p is passed" do assert_raise ArgumentError, ~r|expected compile-time ~p path string, got: "/posts/1"|, fn -> defmodule MissingPathPrefix do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test, do: path(%URI{}, "/posts/1") end end after :code.purge(__MODULE__.MissingPathPrefix) :code.delete(__MODULE__.MissingPathPrefix) end test "url raises when non ~p is passed" do assert_raise ArgumentError, ~r|expected compile-time ~p path string, got: "/posts/1"|, fn -> defmodule MissingURLPrefix do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test, do: url("/posts/1") end end after :code.purge(__MODULE__.MissingURLPrefix) :code.delete(__MODULE__.MissingURLPrefix) end test "static_integrity" do assert is_nil(static_integrity(Endpoint, "/images/foo.png")) assert is_nil(static_integrity(conn_with_endpoint(), "/images/foo.png")) assert is_nil(static_integrity(socket_with_endpoint(), "/images/foo.png")) end test "static paths" do assert path(Endpoint, ~p"/images/foo.png") == "/images/foo.png" assert path(conn_with_endpoint(), ~p"/images/foo.png") == "/images/foo.png" assert path(socket_with_endpoint(), ~p"/images/foo.png") == "/images/foo.png" end test "~p dict query strings" do assert ~p"/posts/5?#{[id: 3]}" == "/posts/5?id=3" assert ~p"/posts/5?#{[foo: "bar"]}" == "/posts/5?foo=bar" assert ~p"/posts/5?#{[foo: :bar]}" == "/posts/5?foo=bar" assert ~p"/posts/5?#{[foo: true]}" == "/posts/5?foo=true" assert ~p"/posts/5?#{[foo: false]}" == "/posts/5?foo=false" assert ~p"/posts/5?#{[foo: nil]}" == "/posts/5?foo=" assert ~p"/posts/5?#{[foo: ~w(bar baz)]}" == "/posts/5?foo[]=bar&foo[]=baz" assert ~p"/posts/5?#{[foo: %{id: 5}]}" == "/posts/5?foo[id]=5" assert ~p"/posts/5?#{[foo: %{__struct__: Foo, id: 5}]}" == "/posts/5?foo=5" # {key, value} params pairs are sorted assert ~p"/posts/5?#{[b: 2, a: 1, c: 3]}" == "/posts/5?a=1&b=2&c=3" assert ~p"/posts/5?#{%{b: 2, a: 1, c: 3}}" == "/posts/5?a=1&b=2&c=3" # array values are sorted assert ~p"/posts/5?#{[foo: ~w(b a)]}" == "/posts/5?foo[]=a&foo[]=b" # ampersands are escaped and won't mess with splitting query at '&' assert ~p"/posts/5?#{[foo: "bar", "a&b": "e&f"]}" == "/posts/5?a%26b=e%26f&foo=bar" end test "~p mixed query string interpolation" do dir = "asc" page = "pg" assert ~p"/posts/5?page=#{3}" == "/posts/5?page=3" assert ~p"/posts/5?page=#{3}&dir=#{dir}" == "/posts/5?page=3&dir=asc" assert ~p"/posts/5?#{page}=#{3}&dir=#{dir}" == "/posts/5?pg=3&dir=asc" assert ~p"/posts/5?#{"a b"}=#{3}&dir=#{"a b"}" == "/posts/5?a+b=3&dir=a+b" assert ~p"/posts/post?foo=bar&#{"key"}=#{"val"}&baz=bat" == "/posts/post?foo=bar&key=val&baz=bat" assert ~p"/posts/#{page}?foo=bar&#{"key"}=#{"val"}&baz=bat" == "/posts/pg?foo=bar&key=val&baz=bat" end test "invalid mixed interpolation query string raises" do msg = ~S|interpolated query string params must be separated by &, got: "/posts/5?page=#{3}#{dir}"| assert_raise ArgumentError, msg, fn -> defmodule InvalidQuery do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test do ~p"/posts/5?page=#{3}#{dir}" == "/posts/5?page=3" end end end after :code.purge(__MODULE__.InvalidQuery) :code.delete(__MODULE__.InvalidQuery) end test "~p with complex ids" do assert ~p|/posts/#{"==d--+"}| == "/posts/%3D%3Dd--%2B" assert ~p|/posts/top?#{[id: "==d--+"]}| == "/posts/top?id=%3D%3Dd--%2B" assert ~p|/posts/file/#{"==d--+"}/#{":O.jpg"}| == "/posts/file/%3D%3Dd--%2B/%3AO.jpg" assert ~p|/posts/file/#{"==d--+"}/#{":O.jpg"}?#{[xx: "/=+/"]}| == "/posts/file/%3D%3Dd--%2B/%3AO.jpg?xx=%2F%3D%2B%2F" end test "~p with trailing slashes" do assert ~p"/posts/5/" == "/posts/5/" assert ~p"/posts/5/?#{[id: 5]}" == "/posts/5/?id=5" assert ~p"/posts/5/?#{%{"id" => "foo"}}" == "/posts/5/?id=foo" assert ~p"/posts/5/?#{%{"id" => "foo bar"}}" == "/posts/5/?id=foo+bar" end test "~p with unicode characters" do assert ~p"/ø" == "/%C3%B8" end describe "with static path" do @endpoint StaticPath @router Router test "paths use static prefix" do assert ~p"/images/foo.png" == "/static/images/foo.png" assert path(conn_with_endpoint(StaticPath), ~p"/images/foo.png") == "/static/images/foo.png" assert path(socket_with_endpoint(StaticPath), ~p"/images/foo.png") == "/static/images/foo.png" assert url(conn_with_endpoint(StaticPath), ~p"/images/foo.png") == "https://example.com/static/images/foo.png" assert url(socket_with_endpoint(StaticPath), ~p"/images/foo.png") == "https://example.com/static/images/foo.png" end end describe "with script name" do @endpoint ScriptName @router Router test "paths use script name" do assert ~p"/" == "/api/" assert path(ScriptName, Router, ~p"/") == "/api/" assert path(conn_with_script_name(), ~p"/") == "/api/" assert path(uri_with_script_name(), ~p"/") == "/api/" assert path(ScriptName, Router, ~p"/posts/5") == "/api/posts/5" assert ~p"/posts/5" == "/api/posts/5" assert path(ScriptName, Router, ~p"/posts/#{123}") == "/api/posts/123" assert ~p"/posts/#{123}" == "/api/posts/123" assert path(uri_with_script_name(), ~p"/posts/5") == "/api/posts/5" assert path(uri_with_script_name(), ~p"/posts/#{123}") == "/api/posts/123" end test "urls use script name" do assert url(ScriptName, ~p"/") == "https://example.com/api/" assert url(conn_with_script_name(~w(foo)), ~p"/") == "https://example.com/foo/" assert url(uri_with_script_name(), ~p"/") == "https://example.com:123/api/" assert url(ScriptName, ~p"/posts/5") == "https://example.com/api/posts/5" assert url(ScriptName, ~p"/posts/#{123}") == "https://example.com/api/posts/123" assert url(conn_with_script_name(), ~p"/posts/5") == "https://example.com/api/posts/5" assert url(conn_with_script_name(~w(foo)), ~p"/posts/5") == "https://example.com/foo/posts/5" assert url(uri_with_script_name(), ~p"/posts/5") == "https://example.com:123/api/posts/5" end test "static use endpoint script name only" do assert path(conn_with_script_name(~w(foo)), ~p"/images/foo.png") == "/api/images/foo.png" assert url(conn_with_script_name(~w(foo)), ~p"/images/foo.png") == "https://static.example.com/api/images/foo.png" end test "phoenix_router_url with string takes precedence over endpoint" do url = "https://phoenixframework.org" conn = Phoenix.Controller.put_router_url(conn_with_endpoint(), url) assert url(conn, ~p"/") == url <> "/" assert url(conn, ~p"/admin/new/messages/1") == url <> "/admin/new/messages/1" assert url(conn, ~p"/admin/new/messages/#{123}") == url <> "/admin/new/messages/123" end test "phoenix_router_url with URI takes precedence over endpoint" do uri = %URI{scheme: "https", host: "phoenixframework.org", port: 123, path: "/path"} conn = Phoenix.Controller.put_router_url(conn_with_endpoint(), uri) assert url(conn, ~p"/") == "https://phoenixframework.org:123/path/" assert url(conn, ~p"/admin/new/messages/1") == "https://phoenixframework.org:123/path/admin/new/messages/1" end test "phoenix_static_url with string takes precedence over endpoint" do url = "https://phoenixframework.org" conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), url) assert url(conn, ~p"/images/foo.png") == url <> "/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), url) assert url(conn, ~p"/images/foo.png") == url <> "/images/foo.png" end test "phoenix_static_url set to string with path results in static url with that path" do url = "https://phoenixframework.org/path" conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), url) assert url(conn, ~p"/images/foo.png") == url <> "/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), url) assert url(conn, ~p"/images/foo.png") == url <> "/images/foo.png" end test "phoenix_static_url with URI takes precedence over endpoint" do uri = %URI{scheme: "https", host: "phoenixframework.org", port: 123} conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), uri) assert url(conn, ~p"/images/foo.png") == "https://phoenixframework.org:123/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), uri) assert url(conn, ~p"/images/foo.png") == "https://phoenixframework.org:123/images/foo.png" end test "phoenix_static_url set to URI with path results in static url with that path" do uri = %URI{scheme: "https", host: "phoenixframework.org", port: 123, path: "/path"} conn = Phoenix.Controller.put_static_url(conn_with_endpoint(), uri) assert url(conn, ~p"/images/foo.png") == "https://phoenixframework.org:123/path/images/foo.png" conn = Phoenix.Controller.put_static_url(conn_with_script_name(), uri) assert url(conn, ~p"/images/foo.png") == "https://phoenixframework.org:123/path/images/foo.png" end end describe "warnings" do test "forwards" do warnings = ExUnit.CaptureIO.capture_io(:stderr, fn -> defmodule Forwards do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test do "/router_forward/dashboard" = ~p"/router_forward/dashboard" "/router_forward/warn" = ~p"/router_forward/warn" "/plug_forward/home" = ~p"/plug_forward/home" end end end) line = __ENV__.line - 6 warnings = String.replace(warnings, ~r/(\x9B|\x1B\[)[0-?]*[ -\/]*[@-~]/, "") assert warnings =~ "warning: no route path for Phoenix.VerifiedRoutesTest.Router matches \"/router_forward/warn\"" assert warnings =~ ~r"test/phoenix/verified_routes_test.exs:#{line}:(\d+:)? Phoenix.VerifiedRoutesTest.Forwards.test/0" after :code.purge(__MODULE__.Forwards) :code.delete(__MODULE__.Forwards) end test "~p warns on unmatched path" do warnings = ExUnit.CaptureIO.capture_io(:stderr, fn -> defmodule Unmatched do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test do ~p"/unknown" ~p"/unknown/123" ~p"/unknown/#{123}" end end end) assert warnings =~ ~s|no route path for Phoenix.VerifiedRoutesTest.Router matches "/unknown"| assert warnings =~ ~s|no route path for Phoenix.VerifiedRoutesTest.Router matches "/unknown/123"| assert warnings =~ ~s|no route path for Phoenix.VerifiedRoutesTest.Router matches "/unknown/#{123}"| after :code.purge(__MODULE__.Unmatched) :code.delete(__MODULE__.Unmatched) end test "~p warns on warn_on_verify: true route" do warnings = ExUnit.CaptureIO.capture_io(:stderr, fn -> defmodule VerifyFalse do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: unquote(@router) def test, do: ~p"/should-warn/foobar" end end) assert warnings =~ ~s|no route path for Phoenix.VerifiedRoutesTest.Router matches "/should-warn/foobar"| after :code.purge(__MODULE__.VerifyFalse) :code.delete(__MODULE__.VerifyFalse) end test "~p does not warn if route without warn_on_verify: true matches first" do warnings = ExUnit.CaptureIO.capture_io(:stderr, fn -> defmodule VerifyFalseTrueMatchesFirst do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: CatchAllWarningRouter def test, do: ~p"/" end end) refute warnings =~ "no route path for Phoenix.VerifiedRoutesTest.CatchAllWarningRouter matches" after :code.purge(__MODULE__.VerifyFalseTrueMatchesFirst) :code.delete(__MODULE__.VerifyFalseTrueMatchesFirst) end test "routers implementing verified routes behavior warn as expected" do warnings = ExUnit.CaptureIO.capture_io(:stderr, fn -> defmodule VerifyForwardedRouter do use Phoenix.VerifiedRoutes, endpoint: unquote(@endpoint), router: PlugRouterWithVerifiedRoutes def test, do: ~p"/bar" def test2, do: ~p"/foo" end end) assert warnings =~ "no route path for PlugRouterWithVerifiedRoutes matches \"/bar\"" refute warnings =~ "no route path for PlugRouterWithVerifiedRoutes matches \"/foo\"" after :code.purge(__MODULE__.VerifyForwardedRouter) :code.delete(__MODULE__.VerifyForwardedRouter) end end end ================================================ FILE: test/support/endpoint_helper.exs ================================================ defmodule Phoenix.Integration.EndpointHelper do @moduledoc """ Utility functions for integration testing endpoints. """ @doc """ Finds `n` unused network port numbers. """ def get_unused_port_numbers(n) when is_integer(n) and n > 1 do (1..n) # Open up `n` sockets at the same time, so we don't get # duplicate port numbers |> Enum.map(&listen_on_os_assigned_port/1) |> Enum.map(&get_port_number_and_close/1) end defp listen_on_os_assigned_port(_) do {:ok, socket} = :gen_tcp.listen(0, []) socket end defp get_port_number_and_close(socket) do {:ok, port_number} = :inet.port(socket) :gen_tcp.close(socket) port_number end end ================================================ FILE: test/support/http_client.exs ================================================ defmodule Phoenix.Integration.HTTPClient do @doc """ Performs HTTP Request and returns Response * method - The http method, for example :get, :post, :put, etc * url - The string url, for example "http://example.com" * headers - The map of headers * body - The optional string body. If the body is a map, it is converted to a URI encoded string of parameters ## Examples iex> HTTPClient.request(:get, "http://127.0.0.1", %{}) {:ok, %Response{..}) iex> HTTPClient.request(:post, "http://127.0.0.1", %{}, param1: "val1") {:ok, %Response{..}) iex> HTTPClient.request(:get, "http://unknownhost", %{}, param1: "val1") {:error, ...} """ def request(method, url, headers, body \\ "") def request(method, url, headers, body) when is_map body do request(method, url, headers, URI.encode_query(body)) end def request(method, url, headers, body) do url = String.to_charlist(url) headers = headers |> Map.put_new("content-type", "text/html") ct_type = headers["content-type"] |> String.to_charlist header = Enum.map headers, fn {k, v} -> {String.to_charlist(k), String.to_charlist(v)} end # Generate a random profile per request to avoid reuse profile = :crypto.strong_rand_bytes(4) |> Base.encode16 |> String.to_atom {:ok, pid} = :inets.start(:httpc, profile: profile) resp = case method do :get -> :httpc.request(:get, {url, header}, [], [body_format: :binary], pid) _ -> :httpc.request(method, {url, header, ct_type, body}, [], [body_format: :binary], pid) end :inets.stop(:httpc, pid) format_resp(resp) end defp format_resp({:ok, {{_http, status, _status_phrase}, headers, body}}) do {:ok, %{status: status, headers: headers, body: body}} end defp format_resp({:error, reason}), do: {:error, reason} end ================================================ FILE: test/support/router_helper.exs ================================================ defmodule RouterHelper do @moduledoc """ Conveniences for testing routers and controllers. Must not be used to test endpoints as it does some pre-processing (like fetching params) which could skew endpoint tests. """ import Plug.Test defmacro __using__(_) do quote do import Plug.Test import Plug.Conn import RouterHelper end end def call(router, verb, path, params \\ nil, script_name \\ []) do verb |> conn(path, params) |> Plug.Conn.fetch_query_params() |> Map.put(:script_name, script_name) |> router.call(router.init([])) end def action(controller, verb, action, params \\ nil) do conn = conn(verb, "/", params) |> Plug.Conn.fetch_query_params controller.call(conn, controller.init(action)) end end ================================================ FILE: test/support/websocket_client.exs ================================================ defmodule Phoenix.Integration.WebsocketClient do @moduledoc """ A WebSocket client used to test Phoenix.Channel """ use GenServer import Kernel, except: [send: 2] defstruct [ :conn, :request_ref, :websocket, :caller, :status, :resp_headers, :sender, :serializer, closing?: false, topics: %{}, # Use different initial join_ref from ref to # make sure the server is not coupling them. join_ref: 11, ref: 1 ] alias Phoenix.Socket.Message @doc """ Starts the WebSocket client for given ws URL. `Phoenix.Socket.Message`s received from the server are forwarded to the sender pid. """ def connect(sender, url, serializer, headers \\ []) do with {:ok, socket} <- GenServer.start_link(__MODULE__, {sender, serializer}), {:ok, :connected} <- GenServer.call(socket, {:connect, url, headers}) do {:ok, socket} end end @doc """ Closes the socket """ def close(socket) do GenServer.cast(socket, :close) end @doc """ Sends an event to the WebSocket server per the message protocol. """ def send_event(socket, topic, event, msg) do GenServer.call(socket, {:send, %Message{topic: topic, event: event, payload: msg}}) end @doc """ Sends a low-level text message to the client. """ def send(socket, msg) do GenServer.call(socket, {:send, msg}) end @doc """ Sends a heartbeat event """ def send_heartbeat(socket) do send_event(socket, "phoenix", "heartbeat", %{}) end @doc """ Sends join event to the WebSocket server per the Message protocol """ def join(socket, topic, msg) do send_event(socket, topic, "phx_join", msg) end @doc """ Sends leave event to the WebSocket server per the Message protocol """ def leave(socket, topic, msg) do send_event(socket, topic, "phx_leave", msg) end ## GenServer implementation @doc false def init({sender, serializer}) do state = %__MODULE__{sender: sender, serializer: serializer} {:ok, state} end @doc false def handle_call({:connect, url, headers}, from, state) do uri = URI.parse(url) http_scheme = case uri.scheme do "ws" -> :http "wss" -> :https end ws_scheme = case uri.scheme do "ws" -> :ws "wss" -> :wss end path = case uri.query do nil -> uri.path query -> uri.path <> "?" <> query end with {:ok, conn} <- Mint.HTTP.connect(http_scheme, uri.host, uri.port), {:ok, conn, ref} <- Mint.WebSocket.upgrade(ws_scheme, conn, path, headers) do state = %{state | conn: conn, request_ref: ref, caller: from} {:noreply, state} else {:error, reason} -> {:reply, {:error, reason}, state} {:error, conn, reason} -> {:reply, {:error, reason}, put_in(state.conn, conn)} end end def handle_call({:send, msg}, _from, state) do {frame, state} = serialize_msg(msg, state) case stream_frame(state, frame) do {:ok, state} -> {:reply, :ok, state} {:error, state, reason} -> {:reply, {:error, reason}, state} end end @doc false def handle_cast(:close, state) do do_close(state) end defp do_close(state) do # Streaming a close frame may fail if the server has already closed # for writing. _ = stream_frame(state, :close) Mint.HTTP.close(state.conn) {:stop, :normal, state} end @doc false def handle_info(message, state) do case Mint.WebSocket.stream(state.conn, message) do {:ok, conn, responses} -> state = put_in(state.conn, conn) |> handle_responses(responses) if state.closing?, do: do_close(state), else: {:noreply, state} {:error, conn, reason, _responses} -> state = put_in(state.conn, conn) |> reply({:error, reason}) {:noreply, state} :unknown -> {:noreply, state} end end defp handle_responses(state, responses) defp handle_responses(%{request_ref: ref} = state, [{:status, ref, status} | rest]) do put_in(state.status, status) |> handle_responses(rest) end defp handle_responses(%{request_ref: ref} = state, [{:headers, ref, resp_headers} | rest]) do put_in(state.resp_headers, resp_headers) |> handle_responses(rest) end defp handle_responses(%{request_ref: ref} = state, [{:done, ref} | rest]) do case Mint.WebSocket.new(state.conn, ref, state.status, state.resp_headers) do {:ok, conn, websocket} -> %{state | conn: conn, websocket: websocket, status: nil, resp_headers: nil} |> reply({:ok, :connected}) |> handle_responses(rest) {:error, conn, reason} -> put_in(state.conn, conn) |> reply({:error, reason}) end end defp handle_responses(%{request_ref: ref, websocket: websocket} = state, [ {:data, ref, data} | rest ]) when websocket != nil do case Mint.WebSocket.decode(websocket, data) do {:ok, websocket, frames} -> put_in(state.websocket, websocket) |> handle_frames(frames) |> handle_responses(rest) {:error, websocket, reason} -> put_in(state.websocket, websocket) |> reply({:error, reason}) end end defp handle_responses(state, [_response | rest]) do handle_responses(state, rest) end defp handle_responses(state, []), do: state defp handle_frames(state, frames) do {frames, state} = Enum.flat_map_reduce(frames, state, fn # reply to ping with pong {:ping, data} = frame, state -> {:ok, state} = stream_frame(state, {:pong, data}) {[frame], state} # deserialize text and binary frames {:text, text}, state -> frame = case state.serializer do :noop -> {:text, text} serializer -> serializer.decode!(text, opcode: :text) end {[frame], state} {:binary, data}, state -> {[binary_decode(data)], state} # prepare to close the connection when a close frame is received {:close, _code, _data}, state -> {[], put_in(state.closing?, true)} frame, state -> {[frame], state} end) Enum.each(frames, &Kernel.send(state.sender, &1)) state end # Encodes a frame as a binary and sends it along the wire, keeping `conn` # and `websocket` up to date in `state`. defp stream_frame(state, frame) do with {:ok, websocket, data} <- Mint.WebSocket.encode(state.websocket, frame), state = put_in(state.websocket, websocket), {:ok, conn} <- Mint.WebSocket.stream_request_body(state.conn, state.request_ref, data) do {:ok, put_in(state.conn, conn)} else {:error, %Mint.WebSocket{} = websocket, reason} -> {:error, put_in(state.websocket, websocket), reason} {:error, conn, reason} -> {:error, put_in(state.conn, conn), reason} end end # reply to an open GenServer call request if there is one defp reply(state, response) do if state.caller, do: GenServer.reply(state.caller, response) put_in(state.caller, nil) end defp serialize_msg(msg, %{serializer: :noop} = state), do: {msg, state} defp serialize_msg(%Message{payload: {:binary, _}} = msg, %{ref: ref} = state) do {join_ref, state} = join_ref_for(msg, state) msg = Map.merge(msg, %{ref: to_string(ref), join_ref: to_string(join_ref)}) {{:binary, binary_encode_push!(msg)}, put_in(state.ref, ref + 1)} end defp serialize_msg(%Message{} = msg, %{ref: ref} = state) do {join_ref, state} = join_ref_for(msg, state) msg = Map.merge(msg, %{ref: to_string(ref), join_ref: to_string(join_ref)}) {{:text, encode!(msg, state)}, put_in(state.ref, ref + 1)} end defp serialize_msg(msg, state), do: {msg, state} defp join_ref_for( %{topic: topic, event: "phx_join"}, %{topics: topics, join_ref: join_ref} = state ) do topics = Map.put(topics, topic, join_ref) {join_ref, %{state | topics: topics, join_ref: join_ref + 1}} end defp join_ref_for(%{topic: topic}, %{topics: topics} = state) do {Map.get(topics, topic), state} end defp encode!(map, state) do {:socket_push, :text, chardata} = state.serializer.encode!(map) IO.chardata_to_string(chardata) end defp binary_encode_push!(%Message{payload: {:binary, data}} = msg) do ref = to_string(msg.ref) join_ref = to_string(msg.join_ref) join_ref_size = byte_size(join_ref) ref_size = byte_size(ref) topic_size = byte_size(msg.topic) event_size = byte_size(msg.event) << 0::size(8), join_ref_size::size(8), ref_size::size(8), topic_size::size(8), event_size::size(8), join_ref::binary-size(join_ref_size), ref::binary-size(ref_size), msg.topic::binary-size(topic_size), msg.event::binary-size(event_size), data::binary >> end # push defp binary_decode(<< 0::size(8), join_ref_size::size(8), topic_size::size(8), event_size::size(8), join_ref::binary-size(join_ref_size), topic::binary-size(topic_size), event::binary-size(event_size), data::binary >>) do %Message{join_ref: join_ref, topic: topic, event: event, payload: {:binary, data}} end # reply defp binary_decode(<< 1::size(8), join_ref_size::size(8), ref_size::size(8), topic_size::size(8), status_size::size(8), join_ref::binary-size(join_ref_size), ref::binary-size(ref_size), topic::binary-size(topic_size), status::binary-size(status_size), data::binary >>) do payload = %{"status" => status, "response" => {:binary, data}} %Message{join_ref: join_ref, ref: ref, topic: topic, event: "phx_reply", payload: payload} end end ================================================ FILE: test/test_helper.exs ================================================ Code.require_file("support/router_helper.exs", __DIR__) # Starts web server applications Application.ensure_all_started(:plug_cowboy) # Used whenever a router fails. We default to simply # rendering a short string. defmodule Phoenix.ErrorView do def render("404.json", %{kind: kind, reason: _reason, stack: _stack, conn: conn}) do %{error: "Got 404 from #{kind} with #{conn.method}"} end def render(template, %{conn: conn}) do unless conn.private.phoenix_endpoint do raise "no endpoint in error view" end "#{template} from Phoenix.ErrorView" end end # For mix tests Mix.shell(Mix.Shell.Process) assert_timeout = String.to_integer( System.get_env("ELIXIR_ASSERT_TIMEOUT") || "200" ) excludes = if Version.match?(System.version(), "~> 1.15") do [] else [:mix_phx_new] end ExUnit.start(assert_receive_timeout: assert_timeout, exclude: excludes) ================================================ FILE: usage-rules/ecto.md ================================================ ## 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 programmatically, 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 ================================================ FILE: usage-rules/elixir.md ================================================ ## 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 ================================================ FILE: usage-rules/html.md ================================================ ## Phoenix HTML guidelines - Phoenix templates **always** use `~H` or .html.heex files (known as HEEx), **never** use `~E` - **Always** use the imported `Phoenix.Component.form/1` and `Phoenix.Component.inputs_for/1` function to build forms. **Never** use `Phoenix.HTML.form_for` or `Phoenix.HTML.inputs_for` as they are outdated - When building forms **always** use the already imported `Phoenix.Component.to_form/2` (`assign(socket, form: to_form(...))` and `<.form for={@form} id="msg-form">`), then access those forms in the template via `@form[:field]` - **Always** add unique DOM IDs to key elements (like forms, buttons, etc) when writing templates, these IDs can later be used in tests (`<.form for={@form} id="product-form">`) - For "app wide" template imports, you can import/alias into the `my_app_web.ex`'s `html_helpers` block, so they will be available to all LiveViews, LiveComponent's, and all modules that do `use MyAppWeb, :html` (replace "my_app" by the actual app name) - Elixir supports `if/else` but **does NOT support `if/else if` or `if/elsif`**. **Never use `else if` or `elseif` in Elixir**, **always** use `cond` or `case` for multiple conditionals. **Never do this (invalid)**: <%= if condition do %> ... <% else if other_condition %> ... <% end %> Instead **always** do this: <%= cond do %> <% condition -> %> ... <% condition2 -> %> ... <% true -> %> ... <% end %> - HEEx require special tag annotation if you want to insert literal curly's like `{` or `}`. If you want to show a textual code snippet on the page in a `
` or `` block you *must* annotate the parent tag with `phx-no-curly-interpolation`:

      
        let obj = {key: "val"}
      

  Within `phx-no-curly-interpolation` annotated tags, you can use `{` and `}` without escaping them, and dynamic Elixir expressions can still be used with `<%= ... %>` syntax

- HEEx class attrs support lists, but you must **always** use list `[...]` syntax. You can use the class list syntax to conditionally add classes, **always do this for multiple class values**:

      Text

  and **always** wrap `if`'s inside `{...}` expressions with parens, like done above (`if(@other_condition, do: "...", else: "...")`)

  and **never** do this, since it's invalid (note the missing `[` and `]`):

       ...
      => Raises compile syntax error on invalid HEEx attr syntax

- **Never** use `<% Enum.each %>` or non-for comprehensions for generating template content, instead **always** use `<%= for item <- @collection do %>`
- HEEx HTML comments use `<%!-- comment --%>`. **Always** use the HEEx HTML comment syntax for template comments (`<%!-- comment --%>`)
- HEEx allows interpolation via `{...}` and `<%= ... %>`, but the `<%= %>` **only** works within tag bodies. **Always** use the `{...}` syntax for interpolation within tag attributes, and for interpolation of values within tag bodies. **Always** interpolate block constructs (if, cond, case, for) within tag bodies using `<%= ... %>`.

  **Always** do this:

      

        {@my_assign}
        <%= if @some_block_condition do %>
          {@another_assign}
        <% end %>
      


  and **Never** do this – the program will terminate with a syntax error:

      <%!-- THIS IS INVALID NEVER EVER DO THIS --%>
      

        {if @invalid_block_construct do}
        {end}
      



================================================
FILE: usage-rules/liveview.md
================================================
## Phoenix LiveView guidelines

- **Never** use the deprecated `live_redirect` and `live_patch` functions, instead **always** use the `<.link navigate={href}>` and  `<.link patch={href}>` in templates, and `push_navigate` and `push_patch` functions LiveViews
- **Avoid LiveComponent's** unless you have a strong, specific need for them
- LiveViews should be named like `AppWeb.WeatherLive`, with a `Live` suffix. When you go to add LiveView routes to the router, the default `:browser` scope is **already aliased** with the `AppWeb` module, so you can just do `live "/weather", WeatherLive`

### LiveView streams

- **Always** use LiveView streams for collections for assigning regular lists to avoid memory ballooning and runtime termination with the following operations:
  - basic append of N items - `stream(socket, :messages, [new_msg])`
  - resetting stream with new items - `stream(socket, :messages, [new_msg], reset: true)` (e.g. for filtering items)
  - prepend to stream - `stream(socket, :messages, [new_msg], at: -1)`
  - deleting items - `stream_delete(socket, :messages, msg)`

- When using the `stream/3` interfaces in the LiveView, the LiveView template must 1) always set `phx-update="stream"` on the parent element, with a DOM id on the parent element like `id="messages"` and 2) consume the `@streams.stream_name` collection and use the id as the DOM id for each child. For a call like `stream(socket, :messages, [new_msg])` in the LiveView, the template would be:

      

        

          {msg.text}
        

      


- LiveView streams are *not* enumerable, so you cannot use `Enum.filter/2` or `Enum.reject/2` on them. Instead, if you want to filter, prune, or refresh a list of items on the UI, you **must refetch the data and re-stream the entire stream collection, passing reset: true**:

      def handle_event("filter", %{"filter" => filter}, socket) do
        # re-fetch the messages based on the filter
        messages = list_messages(filter)

        {:noreply,
         socket
         |> assign(:messages_empty?, messages == [])
         # reset the stream with the new messages
         |> stream(:messages, messages, reset: true)}
      end

- LiveView streams *do not support counting or empty states*. If you need to display a count, you must track it using a separate assign. For empty states, you can use Tailwind classes:

      

        
        

          {task.name}
        

      


  The above only works if the empty state is the only HTML block alongside the stream for-comprehension.

- When updating an assign that should change content inside any streamed item(s), you MUST re-stream the items
  along with the updated assign:

      def handle_event("edit_message", %{"message_id" => message_id}, socket) do
        message = Chat.get_message!(message_id)
        edit_form = to_form(Chat.change_message(message, %{content: message.content}))

        # re-insert message so @editing_message_id toggle logic takes effect for that stream item
        {:noreply,
         socket
         |> stream_insert(:messages, message)
         |> assign(:editing_message_id, String.to_integer(message_id))
         |> assign(:edit_form, edit_form)}
      end

  And in the template:

      

        

          {message.username}
          <%= if @editing_message_id == message.id do %>
            <%!-- Edit mode --%>
            <.form for={@edit_form} id="edit-form-#{message.id}" phx-submit="save_edit">
              ...
            
          <% end %>
        

      


- **Never** use the deprecated `phx-update="append"` or `phx-update="prepend"` for collections

### LiveView JavaScript interop

- Remember anytime you use `phx-hook="MyHook"` and that JS hook manages its own DOM, you **must** also set the `phx-update="ignore"` attribute
- **Always** provide an unique DOM id alongside `phx-hook` otherwise a compiler error will be raised

LiveView hooks come in two flavors, 1) colocated js hooks for "inline" scripts defined inside HEEx,
and 2) external `phx-hook` annotations where JavaScript object literals are defined and passed to the `LiveSocket` constructor.

#### Inline colocated js hooks

**Never** write raw embedded `

- colocated hooks are automatically integrated into the app.js bundle
- colocated hooks names **MUST ALWAYS** start with a `.` prefix, i.e. `.PhoneNumber`

#### External phx-hook

External JS hooks (`
`) must be placed in `assets/js/` and passed to the
LiveSocket constructor:

    const MyHook = {
      mounted() { ... }
    }
    let liveSocket = new LiveSocket("/live", Socket, {
      hooks: { MyHook }
    });

#### Pushing events between client and server

Use LiveView's `push_event/3` when you need to push events/data to the client for a phx-hook to handle.
**Always** return or rebind the socket on `push_event/3` when pushing events:

    # re-bind socket so we maintain event state to be pushed
    socket = push_event(socket, "my_event", %{...})

    # or return the modified socket directly:
    def handle_event("some_event", _, socket) do
      {:noreply, push_event(socket, "my_event", %{...})}
    end

Pushed events can then be picked up in a JS hook with `this.handleEvent`:

    mounted() {
      this.handleEvent("my_event", data => console.log("from server:", data));
    }

Clients can also push an event to the server and receive a reply with `this.pushEvent`:

    mounted() {
      this.el.addEventListener("click", e => {
        this.pushEvent("my_event", { one: 1 }, reply => console.log("got reply from server:", reply));
      })
    }

Where the server handled it via:

    def handle_event("my_event", %{"one" => 1}, socket) do
      {:reply, %{two: 2}, socket}
    end

### LiveView tests

- `Phoenix.LiveViewTest` module and `LazyHTML` (included) for making your assertions
- Form tests are driven by `Phoenix.LiveViewTest`'s `render_submit/2` and `render_change/2` functions
- Come up with a step-by-step test plan that splits major test cases into small, isolated files. You may start with simpler tests that verify content exists, gradually add interaction tests
- **Always reference the key element IDs you added in the LiveView templates in your tests** for `Phoenix.LiveViewTest` functions like `element/2`, `has_element/2`, selectors, etc
- **Never** tests again raw HTML, **always** use `element/2`, `has_element/2`, and similar: `assert has_element?(view, "#my-form")`
- Instead of relying on testing text content, which can change, favor testing for the presence of key elements
- Focus on testing outcomes rather than implementation details
- Be aware that `Phoenix.Component` functions like `<.form>` might produce different HTML than expected. Test against the output HTML structure, not your mental model of what you expect it to be
- When facing test failures with element selectors, add debug statements to print the actual HTML, but use `LazyHTML` selectors to limit the output, ie:

      html = render(view)
      document = LazyHTML.from_fragment(html)
      matches = LazyHTML.filter(document, "your-complex-selector")
      IO.inspect(matches, label: "Matches")

### Form handling

#### Creating a form from params

If you want to create a form based on `handle_event` params:

    def handle_event("submitted", params, socket) do
      {:noreply, assign(socket, form: to_form(params))}
    end

When you pass a map to `to_form/1`, it assumes said map contains the form params, which are expected to have string keys.

You can also specify a name to nest the params:

    def handle_event("submitted", %{"user" => user_params}, socket) do
      {:noreply, assign(socket, form: to_form(user_params, as: :user))}
    end

#### Creating a form from changesets

When using changesets, the underlying data, form params, and errors are retrieved from it. The `:as` option is automatically computed too. E.g. if you have a user schema:

    defmodule MyApp.Users.User do
      use Ecto.Schema
      ...
    end

And then you create a changeset that you pass to `to_form`:

    %MyApp.Users.User{}
    |> Ecto.Changeset.change()
    |> to_form()

Once the form is submitted, the params will be available under `%{"user" => user_params}`.

In the template, the form form assign can be passed to the `<.form>` function component:

    <.form for={@form} id="todo-form" phx-change="validate" phx-submit="save">
      <.input field={@form[:field]} type="text" />
    

Always give the form an explicit, unique DOM ID, like `id="todo-form"`.

#### Avoiding form errors

**Always** use a form assigned via `to_form/2` in the LiveView, and the `<.input>` component in the template. In the template **always access forms this**:

    <%!-- ALWAYS do this (valid) --%>
    <.form for={@form} id="my-form">
      <.input field={@form[:field]} type="text" />
    

And **never** do this:

    <%!-- NEVER do this (invalid) --%>
    <.form for={@changeset} id="my-form">
      <.input field={@changeset[:field]} type="text" />
    

- You are FORBIDDEN from accessing the changeset in the template as it will cause errors
- **Never** use `<.form let={f} ...>` in the template, instead **always use `<.form for={@form} ...>`**, then drive all form references from the form assign as in `@form[:field]`. The UI should **always** be driven by a `to_form/2` assigned in the LiveView module that is derived from a changeset


================================================
FILE: usage-rules/phoenix.md
================================================
## 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