updated changelog

Co-authored-by: sergeypdev <sergeypoznyak@protonmail.com>

.github/workflows/release.yaml

@@ -21,7 +21,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '>=1.20.3'
+          go-version: '>=1.21.3'
 
       # This step usually is not needed because the /ui/dist is pregenerated locally
       # but its here to ensure that each release embeds the latest admin ui artifacts.
@@ -29,6 +29,13 @@ jobs:
       - name: Build Admin dashboard UI
         run: npm --prefix=./ui ci && npm --prefix=./ui run build
 
+      # Temporary disable as the types can have random generated identifiers making it non-deterministic.
+      #
+      # # Similar to the above, the jsvm types are pregenerated locally
+      # # but its here to ensure that it wasn't forgotten to be executed.
+      # - name: Generate jsvm types
+      #   run: go run ./plugins/jsvm/internal/types/types.go
+
       # The prebuilt golangci-lint doesn't support go 1.18+ yet
       # https://github.com/golangci/golangci-lint/issues/2649
       # - name: Run linter

.goreleaser.yaml

@@ -7,6 +7,7 @@ before:
     - go mod tidy
 
 builds:
+  # used only for tests
   - id: build_cgo
     main: ./examples/base
     binary: pocketbase
@@ -46,14 +47,6 @@ release:
   draft: true
 
 archives:
-  - id: archive_cgo
-    builds: [build_cgo]
-    name_template: '{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}_cgo'
-    format: zip
-    files:
-      - LICENSE*
-      - CHANGELOG*
-
   - id: archive_noncgo
     builds: [build_noncgo]
     format: zip

CHANGELOG.md

@@ -1,6 +1,542 @@
-## v0.16.1
+## v0.19.4
 
-> _To update the prebuilt executable you can run `./pocketbase update`._
+- Fixed TinyMCE source code viewer textarea styles ([#3715](https://github.com/pocketbase/pocketbase/issues/3715)).
+
+- Fixed `text` field min/max validators to properly count multi-byte characters ([#3735](https://github.com/pocketbase/pocketbase/issues/3735)).
+
+- Allowed hyphens in `username` ([#3697](https://github.com/pocketbase/pocketbase/issues/3697)).
+  _More control over the system fields settings will be available in the future._
+
+- Updated the JSVM generated types to use directly the value type instead of `* | undefined` union in functions/methods return declarations.
+
+
+## v0.19.3
+
+- Added the release notes to the console output of `./pocketbase update` ([#3685](https://github.com/pocketbase/pocketbase/discussions/3685)).
+
+- Added missing documention for the JSVM `$mails.*` bindings.
+
+- Relaxed the OAuth2 redirect url validation to allow any string value ([#3689](https://github.com/pocketbase/pocketbase/pull/3689); thanks @sergeypdev).
+  _Note that the redirect url format is still bound to the accepted values by the specific OAuth2 provider._
+
+
+## v0.19.2
+
+- Updated the JSVM generated types ([#3627](https://github.com/pocketbase/pocketbase/issues/3627), [#3662](https://github.com/pocketbase/pocketbase/issues/3662)).
+
+
+## v0.19.1
+
+- Fixed `tokenizer.Scan()/ScanAll()` to ignore the separators from the default trim cutset.
+  An option to return also the empty found tokens was also added via `Tokenizer.KeepEmptyTokens(true)`.
+  _This should fix the parsing of whitespace charactes around view query column names when no quotes are used ([#3616](https://github.com/pocketbase/pocketbase/discussions/3616#discussioncomment-7398564))._
+
+- Fixed the `:excerpt(max, withEllipsis?)` `field` query param modifier to properly add space to the generated text fragment after block tags.
+
+
+## v0.19.0
+
+- Added Patreon OAuth2 provider ([#3323](https://github.com/pocketbase/pocketbase/pull/3323); thanks @ghostdevv).
+
+- Added mailcow OAuth2 provider ([#3364](https://github.com/pocketbase/pocketbase/pull/3364); thanks @thisni1s).
+
+- Added support for `:excerpt(max, withEllipsis?)` `fields` modifier that will return a short plain text version of any string value (html tags are stripped).
+    This could be used to minimize the downloaded json data when listing records with large `editor` html values.
+    ```js
+    await pb.collection("example").getList(1, 20, {
+      "fields": "*,description:excerpt(100)"
+    })
+    ```
+
+- Several Admin UI improvements:
+  - Count the total records separately to speed up the query execution for large datasets ([#3344](https://github.com/pocketbase/pocketbase/issues/3344)).
+  - Enclosed the listing scrolling area within the table so that the horizontal scrollbar and table header are always reachable ([#2505](https://github.com/pocketbase/pocketbase/issues/2505)).
+  - Allowed opening the record preview/update form via direct URL ([#2682](https://github.com/pocketbase/pocketbase/discussions/2682)).
+  - Reintroduced the local `date` field tooltip on hover.
+  - Speed up the listing loading times for records with large `editor` field values by initially fetching only a partial of the records data (the complete record data is loaded on record preview/update).
+  - Added "Media library" (collection images picker) support for the TinyMCE `editor` field.
+  - Added support to "pin" collections in the sidebar.
+  - Added support to manually resize the collections sidebar.
+  - More clear "Nonempty" field label style.
+  - Removed the legacy `.woff` and `.ttf` fonts and keep only `.woff2`.
+
+- Removed the explicit `Content-Type` charset from the realtime response due to compatibility issues with IIS ([#3461](https://github.com/pocketbase/pocketbase/issues/3461)).
+  _The `Connection:keep-alive` realtime response header was also removed as it is not really used with HTTP2 anyway._
+
+- Added new JSVM bindings:
+  - `new Cookie({ ... })` constructor for creating `*http.Cookie` equivalent value.
+  - `new SubscriptionMessage({ ... })` constructor for creating a custom realtime subscription payload.
+  - Soft-deprecated `$os.exec()` in favour of `$os.cmd()` to make it more clear that the call only prepares the command and doesn't execute it.
+
+- ⚠️ Bumped the min required Go version to 1.19.
+
+
+## v0.18.10
+
+- Added global `raw` template function to allow outputting raw/verbatim HTML content in the JSVM templates ([#3476](https://github.com/pocketbase/pocketbase/discussions/3476)).
+  ```
+  {{.description|raw}}
+  ```
+
+- Trimmed view query semicolon and allowed single quotes for column aliases ([#3450](https://github.com/pocketbase/pocketbase/issues/3450#issuecomment-1748044641)).
+  _Single quotes are usually [not a valid identifier quote characters](https://www.sqlite.org/lang_keywords.html), but for resilience and compatibility reasons SQLite allows them in some contexts where only an identifier is expected._
+
+- Bumped the GitHub action to use [min Go 1.21.2](https://github.com/golang/go/issues?q=milestone%3AGo1.21.2) (_the fixed issues are not critical as they are mostly related to the compiler/build tools_).
+
+
+## v0.18.9
+
+- Fixed empty thumbs directories not getting deleted on Windows after deleting a record img file ([#3382](https://github.com/pocketbase/pocketbase/issues/3382)).
+
+- Updated the generated JSVM typings to silent the TS warnings when trying to access a field/method in a Go->TS interface.
+
+
+## v0.18.8
+
+- Minor fix for the View collections API Preview and Admin UI listings incorrectly showing the `created` and `updated` fields as `N/A` when the view query doesn't have them.
+
+
+## v0.18.7
+
+- Fixed JS error in the Admin UI when listing records with invalid `relation` field value ([#3372](https://github.com/pocketbase/pocketbase/issues/3372)).
+  _This could happen usually only during custom SQL import scripts or when directly modifying the record field value without data validations._
+
+- Updated Go deps and the generated JSVM types.
+
+
+## v0.18.6
+
+- Return the response headers and cookies in the `$http.send()` result ([#3310](https://github.com/pocketbase/pocketbase/discussions/3310)).
+
+- Added more descriptive internal error message for missing user/admin email on password reset requests.
+
+- Updated Go deps.
+
+
+## v0.18.5
+
+- Fixed minor Admin UI JS error in the auth collection options panel introduced with the change from v0.18.4.
+
+
+## v0.18.4
+
+- Added escape character (`\`) support in the Admin UI to allow using `select` field values with comma ([#2197](https://github.com/pocketbase/pocketbase/discussions/2197)).
+
+
+## v0.18.3
+
+- Exposed a global JSVM `readerToString(reader)` helper function to allow reading Go `io.Reader` values ([#3273](https://github.com/pocketbase/pocketbase/discussions/3273)).
+
+- Bumped the GitHub action to use [min Go 1.21.1](https://github.com/golang/go/issues?q=milestone%3AGo1.21.1+label%3ACherryPickApproved) for the prebuilt executable since it contains some minor `html/template` and `net/http` security fixes.
+
+
+## v0.18.2
+
+- Prevent breaking the record form in the Admin UI in case the browser's localStorage quota has been exceeded when uploading or storing large `editor` values ([#3265](https://github.com/pocketbase/pocketbase/issues/3265)).
+
+- Updated docs and missing JSVM typings.
+
+- Exposed additional crypto primitives under the `$security.*` JSVM namespace ([#3273](https://github.com/pocketbase/pocketbase/discussions/3273)):
+  ```js
+  // HMAC with SHA256
+  $security.hs256("hello", "secret")
+
+  // HMAC with SHA512
+  $security.hs512("hello", "secret")
+
+  // compare 2 strings with a constant time
+  $security.equal(hash1, hash2)
+  ```
+
+
+## v0.18.1
+
+- Excluded the local temp dir from the backups ([#3261](https://github.com/pocketbase/pocketbase/issues/3261)).
+
+
+## v0.18.0
+
+- Simplified the `serve` command to accept domain name(s) as argument to reduce any additional manual hosts setup that sometimes previously was needed when deploying on production ([#3190](https://github.com/pocketbase/pocketbase/discussions/3190)).
+  ```sh
+  ./pocketbase serve yourdomain.com
+  ```
+
+- Added `fields` wildcard (`*`) support.
+
+- Added option to upload a backup file from the Admin UI ([#2599](https://github.com/pocketbase/pocketbase/issues/2599)).
+
+- Registered a custom Deflate compressor to speedup (_nearly 2-3x_) the backups generation for the sake of a small zip size increase.
+  _Based on several local tests, `pb_data` of ~500MB (from which ~350MB+ are several hundred small files) results in a ~280MB zip generated for ~11s (previously it resulted in ~250MB zip but for ~35s)._
+
+- Added the application name as part of the autogenerated backup name for easier identification ([#3066](https://github.com/pocketbase/pocketbase/issues/3066)).
+
+- Added new `SmtpConfig.LocalName` option to specify a custom domain name (or IP address) for the initial EHLO/HELO exchange ([#3097](https://github.com/pocketbase/pocketbase/discussions/3097)).
+  _This is usually required for verification purposes only by some SMTP providers, such as on-premise [Gmail SMTP-relay](https://support.google.com/a/answer/2956491)._
+
+- Added `NoDecimal` `number` field option.
+
+- `editor` field improvements:
+    - Added new "Strip urls domain" option to allow controlling the default TinyMCE urls behavior (_default to `false` for new content_).
+    - Normalized pasted text while still preserving links, lists, tables, etc. formatting ([#3257](https://github.com/pocketbase/pocketbase/issues/3257)).
+
+- Added option to auto generate admin and auth record passwords from the Admin UI.
+
+- Added JSON validation and syntax highlight for the `json` field in the Admin UI ([#3191](https://github.com/pocketbase/pocketbase/issues/3191)).
+
+- Added datetime filter macros:
+  ```
+  // all macros are UTC based
+  @second     - @now second number (0-59)
+  @minute     - @now minute number (0-59)
+  @hour       - @now hour number (0-23)
+  @weekday    - @now weekday number (0-6)
+  @day        - @now day number
+  @month      - @now month number
+  @year       - @now year number
+  @todayStart - beginning of the current day as datetime string
+  @todayEnd   - end of the current day as datetime string
+  @monthStart - beginning of the current month as datetime string
+  @monthEnd   - end of the current month as datetime string
+  @yearStart  - beginning of the current year as datetime string
+  @yearEnd    - end of the current year as datetime string
+  ```
+
+- Added cron expression macros ([#3132](https://github.com/pocketbase/pocketbase/issues/3132)):
+  ```
+  @yearly   - "0 0 1 1 *"
+  @annually - "0 0 1 1 *"
+  @monthly  - "0 0 1 * *"
+  @weekly   - "0 0 * * 0"
+  @daily    - "0 0 * * *"
+  @midnight - "0 0 * * *"
+  @hourly   - "0 * * * *"
+  ```
+
+- ⚠️ Added offset argument `Dao.FindRecordsByFilter(collection, filter, sort, limit, offset, [params...])`.
+  _If you don't need an offset, you can set it to `0`._
+
+- To minimize the footguns with `Dao.FindFirstRecordByFilter()` and `Dao.FindRecordsByFilter()`, the functions now supports an optional placeholder params argument that is safe to be populated with untrusted user input.
+  The placeholders are in the same format as when binding regular SQL parameters.
+  ```go
+  // unsanitized and untrusted filter variables
+  status := "..."
+  author := "..."
+
+  app.Dao().FindFirstRecordByFilter("articles", "status={:status} && author={:author}", dbx.Params{
+    "status": status,
+    "author": author,
+  })
+
+  app.Dao().FindRecordsByFilter("articles", "status={:status} && author={:author}", "-created", 10, 0, dbx.Params{
+    "status": status,
+    "author": author,
+  })
+  ```
+
+- Added JSVM `$mails.*` binds for the corresponding Go [mails package](https://pkg.go.dev/github.com/pocketbase/pocketbase/mails) functions.
+
+- Added JSVM helper crypto primitives under the `$security.*` namespace:
+  ```js
+  $security.md5(text)
+  $security.sha256(text)
+  $security.sha512(text)
+  ```
+
+- ⚠️ Deprecated `RelationOptions.DisplayFields` in favor of the new `SchemaField.Presentable` option to avoid the duplication when a single collection is referenced more than once and/or by multiple other collections.
+
+- ⚠️ Fill the `LastVerificationSentAt` and `LastResetSentAt` fields only after a successfull email send ([#3121](https://github.com/pocketbase/pocketbase/issues/3121)).
+
+- ⚠️ Skip API `fields` json transformations for non 20x responses ([#3176](https://github.com/pocketbase/pocketbase/issues/3176)).
+
+- ⚠️ Changes to `tests.ApiScenario` struct:
+
+    - The `ApiScenario.AfterTestFunc` now receive as 3rd argument `*http.Response` pointer instead of `*echo.Echo` as the latter is not really useful in this context.
+      ```go
+      // old
+      AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo)
+
+      // new
+      AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response)
+      ```
+
+    - The `ApiScenario.TestAppFactory` now accept the test instance as argument and no longer expect an error as return result ([#3025](https://github.com/pocketbase/pocketbase/discussions/3025#discussioncomment-6592272)).
+      ```go
+      // old
+      TestAppFactory: func() (*tests.TestApp, error)
+
+      // new
+      TestAppFactory: func(t *testing.T) *tests.TestApp
+      ```
+      _Returning a `nil` app instance from the factory results in test failure. You can enforce a custom test failure by calling `t.Fatal(err)` inside the factory._
+
+- Bumped the min required TLS version to 1.2 in order to improve the cert reputation score.
+
+- Reduced the default JSVM prewarmed pool size to 25 to reduce the initial memory consumptions (_you can manually adjust the pool size with `--hooksPool=50` if you need to, but the default should suffice for most cases_).
+
+- Update `gocloud.dev` dependency to v0.34 and explicitly set the new `NoTempDir` fileblob option to prevent the cross-device link error introduced with v0.33.
+
+- Other minor Admin UI and docs improvements.
+
+
+## v0.17.7
+
+- Fixed the autogenerated `down` migrations to properly revert the old collection rules in case a change was made in `up` ([#3192](https://github.com/pocketbase/pocketbase/pull/3192); thanks @impact-merlinmarek).
+  _Existing `down` migrations can't be fixed but that should be ok as usually the `down` migrations are rarely used against prod environments since they can cause data loss and, while not ideal, the previous old behavior of always setting the rules to `null/nil` is safer than not updating the rules at all._
+
+- Updated some Go deps.
+
+
+## v0.17.6
+
+- Fixed JSVM `require()` file path error when using Windows-style path delimiters ([#3163](https://github.com/pocketbase/pocketbase/issues/3163#issuecomment-1685034438)).
+
+
+## v0.17.5
+
+- Added quotes around the wrapped view query columns introduced with v0.17.4.
+
+
+## v0.17.4
+
+- Fixed Views record retrieval when numeric id is used ([#3110](https://github.com/pocketbase/pocketbase/issues/3110)).
+  _With this fix we also now properly recognize `CAST(... as TEXT)` and `CAST(... as BOOLEAN)` as `text` and `bool` fields._
+
+- Fixed `relation` "Cascade delete" tooltip message ([#3098](https://github.com/pocketbase/pocketbase/issues/3098)).
+
+- Fixed jsvm error message prefix on failed migrations ([#3103](https://github.com/pocketbase/pocketbase/pull/3103); thanks @nzhenev).
+
+- Disabled the initial Admin UI admins counter cache when there are no initial admins to allow detecting externally created accounts (eg. with the `admin` command) ([#3106](https://github.com/pocketbase/pocketbase/issues/3106)).
+
+- Downgraded `google/go-cloud` dependency to v0.32.0 until v0.34.0 is released to prevent the `os.TempDir` `cross-device link` errors as too many users complained about it.
+
+
+## v0.17.3
+
+- Fixed Docker `cross-device link` error when creating `pb_data` backups on a local mounted volume ([#3089](https://github.com/pocketbase/pocketbase/issues/3089)).
+
+- Fixed the error messages for relation to views ([#3090](https://github.com/pocketbase/pocketbase/issues/3090)).
+
+- Always reserve space for the scrollbar to reduce the layout shifts in the Admin UI records listing due to the deprecated `overflow: overlay`.
+
+- Enabled lazy loading for the Admin UI thumb images.
+
+
+## v0.17.2
+
+- Soft-deprecated `$http.send({ data: object, ... })` in favour of `$http.send({ body: rawString, ... })`
+  to allow sending non-JSON body with the request ([#3058](https://github.com/pocketbase/pocketbase/discussions/3058)).
+  The existing `data` prop will still work, but it is recommended to use `body` instead (_to send JSON you can use `JSON.stringify(...)` as body value_).
+
+- Added `core.RealtimeConnectEvent.IdleTimeout` field to allow specifying a different realtime idle timeout duration per client basis ([#3054](https://github.com/pocketbase/pocketbase/discussions/3054)).
+
+- Fixed `apis.RequestData` deprecation log note ([#3068](https://github.com/pocketbase/pocketbase/pull/3068); thanks @gungjodi).
+
+
+## v0.17.1
+
+- Use relative path when redirecting to the OAuth2 providers page in the Admin UI to support subpath deployments ([#3026](https://github.com/pocketbase/pocketbase/pull/3026); thanks @sonyarianto).
+
+- Manually trigger the `OnBeforeServe` hook for `tests.ApiScenario` ([#3025](https://github.com/pocketbase/pocketbase/discussions/3025)).
+
+- Trigger the JSVM `cronAdd()` handler only on app `serve` to prevent unexpected (and eventually duplicated) cron handler calls when custom console commands are used ([#3024](https://github.com/pocketbase/pocketbase/discussions/3024#discussioncomment-6592703)).
+
+- The `console.log()` messages are now written to the `stdout` instead of `stderr`.
+
+
+## v0.17.0
+
+- New more detailed guides for using PocketBase as framework (both Go and JS).
+  _If you find any typos or issues with the docs please report them in https://github.com/pocketbase/site._
+
+- Added new experimental JavaScript app hooks binding via [goja](https://github.com/dop251/goja).
+  They are available by default with the prebuilt executable if you create `*.pb.js` file(s) in the `pb_hooks` directory.
+  Lower your expectations because the integration comes with some limitations. For more details please check the [Extend with JavaScript](https://pocketbase.io/docs/js-overview/) guide.
+  Optionally, you can also enable the JS app hooks as part of a custom Go build for dynamic scripting but you need to register the `jsvm` plugin manually:
+  ```go
+  jsvm.MustRegister(app core.App, config jsvm.Config{})
+  ```
+
+- Added Instagram OAuth2 provider ([#2534](https://github.com/pocketbase/pocketbase/pull/2534); thanks @pnmcosta).
+
+- Added VK OAuth2 provider ([#2533](https://github.com/pocketbase/pocketbase/pull/2533); thanks @imperatrona).
+
+- Added Yandex OAuth2 provider ([#2762](https://github.com/pocketbase/pocketbase/pull/2762); thanks @imperatrona).
+
+- Added new fields to `core.ServeEvent`:
+  ```go
+  type ServeEvent struct {
+    App    App
+    Router *echo.Echo
+    // new fields
+    Server      *http.Server      // allows adjusting the HTTP server config (global timeouts, TLS options, etc.)
+    CertManager *autocert.Manager // allows adjusting the autocert options (cache dir, host policy, etc.)
+  }
+  ```
+
+- Added `record.ExpandedOne(rel)` and `record.ExpandedAll(rel)` helpers to retrieve casted single or multiple expand relations from the already loaded "expand" Record data.
+
+- Added rule and filter record `Dao` helpers:
+  ```go
+  app.Dao().FindRecordsByFilter("posts", "title ~ 'lorem ipsum' && visible = true", "-created", 10)
+  app.Dao().FindFirstRecordByFilter("posts", "slug='test' && active=true")
+  app.Dao().CanAccessRecord(record, requestInfo, rule)
+  ```
+
+- Added `Dao.WithoutHooks()` helper to create a new `Dao` from the current one but without the create/update/delete hooks.
+
+- Use a default fetch function that will return all relations in case the `fetchFunc` argument of `Dao.ExpandRecord(record, expands, fetchFunc)` and `Dao.ExpandRecords(records, expands, fetchFunc)` is `nil`.
+
+- For convenience it is now possible to call `Dao.RecordQuery(collectionModelOrIdentifier)` with just the collection id or name.
+  In case an invalid collection id/name string is passed the query will be resolved with cancelled context error.
+
+- Refactored `apis.ApiError` validation errors serialization to allow `map[string]error` and `map[string]any` when generating the public safe formatted `ApiError.Data`.
+
+- Added support for wrapped API errors (_in case Go 1.20+ is used with multiple wrapped errors, the first `apis.ApiError` takes precedence_).
+
+- Added `?download=1` file query parameter to the file serving endpoint to force the browser to always download the file and not show its preview.
+
+- Added new utility `github.com/pocketbase/pocketbase/tools/template` subpackage to assist with rendering HTML templates using the standard Go `html/template` and `text/template` syntax.
+
+- Added `types.JsonMap.Get(k)` and `types.JsonMap.Set(k, v)` helpers for the cases where the type aliased direct map access is not allowed (eg. in [goja](https://pkg.go.dev/github.com/dop251/goja#hdr-Maps_with_methods)).
+
+- Soft-deprecated `security.NewToken()` in favor of `security.NewJWT()`.
+
+- `Hook.Add()` and `Hook.PreAdd` now returns a unique string identifier that could be used to remove the registered hook handler via `Hook.Remove(handlerId)`.
+
+- Changed the after* hooks to be called right before writing the user response, allowing users to return response errors from the after hooks.
+  There is also no longer need for returning explicitly `hook.StopPropagtion` when writing custom response body in a hook because we will skip the finalizer response body write if a response was already "committed".
+
+- ⚠️ Renamed `*Options{}` to `Config{}` for consistency and replaced the unnecessary pointers with their value equivalent to keep the applied configuration defaults isolated within their function calls:
+  ```go
+  old: pocketbase.NewWithConfig(config *pocketbase.Config) *pocketbase.PocketBase
+  new: pocketbase.NewWithConfig(config pocketbase.Config) *pocketbase.PocketBase
+
+  old: core.NewBaseApp(config *core.BaseAppConfig) *core.BaseApp
+  new: core.NewBaseApp(config core.BaseAppConfig) *core.BaseApp
+
+  old: apis.Serve(app core.App, options *apis.ServeOptions) error
+  new: apis.Serve(app core.App, config apis.ServeConfig) (*http.Server, error)
+
+  old: jsvm.MustRegisterMigrations(app core.App, options *jsvm.MigrationsOptions)
+  new: jsvm.MustRegister(app core.App, config jsvm.Config)
+
+  old: ghupdate.MustRegister(app core.App, rootCmd *cobra.Command, options *ghupdate.Options)
+  new: ghupdate.MustRegister(app core.App, rootCmd *cobra.Command, config ghupdate.Config)
+
+  old: migratecmd.MustRegister(app core.App, rootCmd *cobra.Command, options *migratecmd.Options)
+  new: migratecmd.MustRegister(app core.App, rootCmd *cobra.Command, config migratecmd.Config)
+  ```
+
+- ⚠️ Changed the type of `subscriptions.Message.Data` from `string` to `[]byte` because `Data` usually is a json bytes slice anyway.
+
+- ⚠️ Renamed `models.RequestData` to `models.RequestInfo` and soft-deprecated `apis.RequestData(c)` in favor of `apis.RequestInfo(c)` to avoid the stuttering with the `Data` field.
+  _The old `apis.RequestData()` method still works to minimize the breaking changes but it is recommended to replace it with `apis.RequestInfo(c)`._
+
+- ⚠️ Changes to the List/Search APIs
+    - Added new query parameter `?skipTotal=1` to skip the `COUNT` query performed with the list/search actions ([#2965](https://github.com/pocketbase/pocketbase/discussions/2965)).
+      If `?skipTotal=1` is set, the response fields `totalItems` and `totalPages` will have `-1` value (this is to avoid having different JSON responses and to differentiate from the zero default).
+      With the latest JS SDK 0.16+ and Dart SDK v0.11+ versions `skipTotal=1` is set by default for the `getFirstListItem()` and `getFullList()` requests.
+
+    - The count and regular select statements also now executes concurrently, meaning that we no longer perform normalization over the `page` parameter and in case the user
+      request a page that doesn't exist (eg. `?page=99999999`) we'll return empty `items` array.
+
+    - Reverted the default `COUNT` column to `id` as there are some common situations where it can negatively impact the query performance.
+      Additionally, from this version we also set `PRAGMA temp_store = MEMORY` so that also helps with the temp B-TREE creation when `id` is used.
+      _There are still scenarios where `COUNT` queries with `rowid` executes faster, but the majority of the time when nested relations lookups are used it seems to have the opposite effect (at least based on the benchmarks dataset)._
+
+- ⚠️ Disallowed relations to views **from non-view** collections ([#3000](https://github.com/pocketbase/pocketbase/issues/3000)).
+  The change was necessary because I wasn't able to find an efficient way to track view changes and the previous behavior could have too many unexpected side-effects (eg. view with computed ids).
+  There is a system migration that will convert the existing view `relation` fields to `json` (multiple) and `text` (single) fields.
+  This could be a breaking change if you have `relation` to view and use `expand` or some of the `relation` view fields as part of a collection rule.
+
+- ⚠️ Added an extra `action` argument to the `Dao` hooks to allow skipping the default persist behavior.
+  In preparation for the logs generalization, the `Dao.After*Func` methods now also allow returning an error.
+
+- Allowed `0` as `RelationOptions.MinSelect` value to avoid the ambiguity between 0 and non-filled input value ([#2817](https://github.com/pocketbase/pocketbase/discussions/2817)).
+
+- Fixed zero-default value not being used if the field is not explicitly set when manually creating records ([#2992](https://github.com/pocketbase/pocketbase/issues/2992)).
+  Additionally, `record.Get(field)` will now always return normalized value (the same as in the json serialization) for consistency and to avoid ambiguities with what is stored in the related DB table.
+  The schema fields columns `DEFAULT` definition was also updated for new collections to ensure that `NULL` values can't be accidentally inserted.
+
+- Fixed `migrate down` not returning the correct `lastAppliedMigrations()` when the stored migration applied time is in seconds.
+
+- Fixed realtime delete event to be called after the record was deleted from the DB (_including transactions and cascade delete operations_).
+
+- Other minor fixes and improvements (typos and grammar fixes, updated dependencies, removed unnecessary 404 error check in the Admin UI, etc.).
+
+
+## v0.16.10
+
+- Added multiple valued fields (`relation`, `select`, `file`) normalizations to ensure that the zero-default value of a newly created multiple field is applied for already existing data ([#2930](https://github.com/pocketbase/pocketbase/issues/2930)).
+
+
+## v0.16.9
+
+- Register the `eagerRequestInfoCache` middleware only for the internal `api` group routes to avoid conflicts with custom route handlers ([#2914](https://github.com/pocketbase/pocketbase/issues/2914)).
+
+
+## v0.16.8
+
+- Fixed unique validator detailed error message not being returned when camelCase field name is used ([#2868](https://github.com/pocketbase/pocketbase/issues/2868)).
+
+- Updated the index parser to allow no space between the table name and the columns list ([#2864](https://github.com/pocketbase/pocketbase/discussions/2864#discussioncomment-6373736)).
+
+- Updated go deps.
+
+
+## v0.16.7
+
+- Minor optimization for the list/search queries to use `rowid` with the `COUNT` statement when available.
+  _This eliminates the temp B-TREE step when executing the query and for large datasets (eg. 150k) it could have 10x improvement (from ~580ms to ~60ms)._
+
+
+## v0.16.6
+
+- Fixed collection index column sort normalization in the Admin UI ([#2681](https://github.com/pocketbase/pocketbase/pull/2681); thanks @SimonLoir).
+
+- Removed unnecessary admins count in `apis.RequireAdminAuthOnlyIfAny()` middleware ([#2726](https://github.com/pocketbase/pocketbase/pull/2726); thanks @svekko).
+
+- Fixed `multipart/form-data` request bind not populating map array values ([#2763](https://github.com/pocketbase/pocketbase/discussions/2763#discussioncomment-6278902)).
+
+- Upgraded npm and Go dependencies.
+
+
+## v0.16.5
+
+- Fixed the Admin UI serialization of implicit relation display fields ([#2675](https://github.com/pocketbase/pocketbase/issues/2675)).
+
+- Reset the Admin UI sort in case the active sort collection field is renamed or deleted.
+
+
+## v0.16.4
+
+- Fixed the selfupdate command not working on Windows due to missing `.exe` in the extracted binary path ([#2589](https://github.com/pocketbase/pocketbase/discussions/2589)).
+  _Note that the command on Windows will work from v0.16.4+ onwards, meaning that you still will have to update manually one more time to v0.16.4._
+
+- Added `int64`, `int32`, `uint`, `uint64` and `uint32` support when scanning `types.DateTime` ([#2602](https://github.com/pocketbase/pocketbase/discussions/2602))
+
+- Updated dependencies.
+
+
+## v0.16.3
+
+- Fixed schema fields sort not working on Safari/Gnome Web ([#2567](https://github.com/pocketbase/pocketbase/issues/2567)).
+
+- Fixed default `PRAGMA`s not being applied for new connections ([#2570](https://github.com/pocketbase/pocketbase/discussions/2570)).
+
+
+## v0.16.2
+
+- Fixed backups archive not excluding the local `backups` directory on Windows ([#2548](https://github.com/pocketbase/pocketbase/discussions/2548#discussioncomment-5979712)).
+
+- Changed file field to not use `dataTransfer.effectAllowed` when dropping files since it is not reliable and consistent across different OS and browsers ([#2541](https://github.com/pocketbase/pocketbase/issues/2541)).
+
+- Auto register the initial generated snapshot migration to prevent incorrectly reapplying the snapshot on Docker restart ([#2551](https://github.com/pocketbase/pocketbase/discussions/2551)).
+
+- Fixed missing view id field error message typo.
+
+
+## v0.16.1
 
 - Fixed backup restore not working in a container environment when `pb_data` is mounted as volume ([#2519](https://github.com/pocketbase/pocketbase/issues/2519)).
 
@@ -119,7 +655,7 @@
   It works with a short lived (~5min) file token passed as query param with the file url.
   For more details and example, you could check https://pocketbase.io/docs/files-handling/#protected-files.
 
-- **!** Fixed typo in `Record.WithUnkownData()` -> `Record.WithUnknownData()`.
+- ⚠️ Fixed typo in `Record.WithUnkownData()` -> `Record.WithUnknownData()`.
 
 - Added simple loose wildcard search term support in the Admin UI.
 
@@ -210,16 +746,16 @@
 
 - Added CGO linux target for the prebuilt executable.
 
-- **!** Renamed `daos.GetTableColumns()` to `daos.TableColumns()` for consistency with the other Dao table related helpers.
+- ⚠️ Renamed `daos.GetTableColumns()` to `daos.TableColumns()` for consistency with the other Dao table related helpers.
 
-- **!** Renamed `daos.GetTableInfo()` to `daos.TableInfo()` for consistency with the other Dao table related helpers.
+- ⚠️ Renamed `daos.GetTableInfo()` to `daos.TableInfo()` for consistency with the other Dao table related helpers.
 
-- **!** Changed `types.JsonArray` to support specifying a generic type, aka. `types.JsonArray[T]`.
+- ⚠️ Changed `types.JsonArray` to support specifying a generic type, aka. `types.JsonArray[T]`.
   If you have previously used `types.JsonArray`, you'll have to update it to `types.JsonArray[any]`.
 
-- **!** Registered the `RemoveTrailingSlash` middleware only for the `/api/*` routes since it is causing issues with subpath file serving endpoints ([#2072](https://github.com/pocketbase/pocketbase/issues/2072)).
+- ⚠️ Registered the `RemoveTrailingSlash` middleware only for the `/api/*` routes since it is causing issues with subpath file serving endpoints ([#2072](https://github.com/pocketbase/pocketbase/issues/2072)).
 
-- **!** Changed the request logs `method` value to UPPERCASE, eg. "get" => "GET" ([#1956](https://github.com/pocketbase/pocketbase/discussions/1956)).
+- ⚠️ Changed the request logs `method` value to UPPERCASE, eg. "get" => "GET" ([#1956](https://github.com/pocketbase/pocketbase/discussions/1956)).
 
 - Other minor UI improvements.
 
@@ -276,11 +812,11 @@
 
 - Added `UploadedFiles` field to the `RecordCreateEvent` and `RecordUpdateEvent` event structs.
 
-- **!** Moved file upload after the record persistent to allow setting custom record id safely from the `OnModelBeforeCreate` hook.
+- ⚠️ Moved file upload after the record persistent to allow setting custom record id safely from the `OnModelBeforeCreate` hook.
 
-- **!** Changed `System.GetFile()` to return directly `*blob.Reader` instead of the `io.ReadCloser` interface.
+- ⚠️ Changed `System.GetFile()` to return directly `*blob.Reader` instead of the `io.ReadCloser` interface.
 
-- **!** Changed `To`, `Cc` and `Bcc` of `mailer.Message` to `[]mail.Address` for consistency and to allow multiple recipients and optional name.
+- ⚠️ Changed `To`, `Cc` and `Bcc` of `mailer.Message` to `[]mail.Address` for consistency and to allow multiple recipients and optional name.
 
     If you are sending custom emails, you'll have to replace:
     ```go
@@ -300,11 +836,11 @@
     }
     ```
 
-- **!** Refactored the Authentik integration as a more generic "OpenID Connect" provider (`oidc`) to support any OIDC provider (Okta, Keycloak, etc.).
+- ⚠️ Refactored the Authentik integration as a more generic "OpenID Connect" provider (`oidc`) to support any OIDC provider (Okta, Keycloak, etc.).
   _If you've previously used Authentik, make sure to rename the provider key in your code to `oidc`._
   _To enable more than one OIDC provider you can use the additional `oidc2` and `oidc3` provider keys._
 
-- **!** Removed the previously deprecated `Dao.Block()` and `Dao.Continue()` helpers in favor of `Dao.NonconcurrentDB()`.
+- ⚠️ Removed the previously deprecated `Dao.Block()` and `Dao.Continue()` helpers in favor of `Dao.NonconcurrentDB()`.
 
 - Updated the internal redirects to allow easier subpath deployment when behind a reverse proxy.
 
@@ -409,7 +945,7 @@
     ```
     For all those event hooks `*hook.Hook` was replaced with `*hooks.TaggedHook`, but the hook methods signatures are the same so it should behave as it was previously if no tags were specified.
 
-- **!** Fixed the `json` field **string** value normalization ([#1703](https://github.com/pocketbase/pocketbase/issues/1703)).
+- ⚠️ Fixed the `json` field **string** value normalization ([#1703](https://github.com/pocketbase/pocketbase/issues/1703)).
 
     In order to support seamlessly both `application/json` and `multipart/form-data`
     requests, the following normalization rules are applied if the `json` field is a
@@ -483,7 +1019,7 @@
 
   _Note2: The old index (`"field.0":null`) and filename (`"field.filename.png":null`) based suffixed syntax for deleting files is still supported._
 
-- ! Added support for multi-match/match-all request data and collection multi-valued fields (`select`, `relation`) conditions.
+- ⚠️ Added support for multi-match/match-all request data and collection multi-valued fields (`select`, `relation`) conditions.
   If you want a "at least one of" type of condition, you can prefix the operator with `?`.
   ```js
   // for each someRelA.someRelB record require the "status" field to be "active"
@@ -563,7 +1099,7 @@
 
 ## v0.10.3
 
-- ! Renamed the metadata key `original_filename` to `original-filename` due to an S3 file upload error caused by the underscore character ([#1343](https://github.com/pocketbase/pocketbase/pull/1343); thanks @yuxiang-gao).
+- ⚠️ Renamed the metadata key `original_filename` to `original-filename` due to an S3 file upload error caused by the underscore character ([#1343](https://github.com/pocketbase/pocketbase/pull/1343); thanks @yuxiang-gao).
 
 - Fixed request verification docs api url ([#1332](https://github.com/pocketbase/pocketbase/pull/1332); thanks @JoyMajumdar2001)
 
@@ -599,7 +1135,7 @@
 
 - Refactored the `core.app.Bootstrap()` to be called before starting the cobra commands ([#1267](https://github.com/pocketbase/pocketbase/discussions/1267)).
 
-- ! Changed `pocketbase.NewWithConfig(config Config)` to `pocketbase.NewWithConfig(config *Config)` and added 4 new config settings:
+- ⚠️ Changed `pocketbase.NewWithConfig(config Config)` to `pocketbase.NewWithConfig(config *Config)` and added 4 new config settings:
   ```go
   DataMaxOpenConns int // default to core.DefaultDataMaxOpenConns
   DataMaxIdleConns int // default to core.DefaultDataMaxIdleConns
@@ -609,9 +1145,9 @@
 
 - Added new helper method `core.App.IsBootstrapped()` to check the current app bootstrap state.
 
-- ! Changed `core.NewBaseApp(dir, encryptionEnv, isDebug)` to `NewBaseApp(config *BaseAppConfig)`.
+- ⚠️ Changed `core.NewBaseApp(dir, encryptionEnv, isDebug)` to `NewBaseApp(config *BaseAppConfig)`.
 
-- ! Removed `rest.UploadedFile` struct (see below `filesystem.File`).
+- ⚠️ Removed `rest.UploadedFile` struct (see below `filesystem.File`).
 
 - Added generic file resource struct that allows loading and uploading file content from
   different sources (at the moment multipart/form-data requests and from the local filesystem).

CONTRIBUTING.md

@@ -1,5 +1,4 @@
-Contributing to PocketBase
-======================================================================
+# Contributing to PocketBase
 
 Thanks for taking the time to improve PocketBase!
 
@@ -9,26 +8,26 @@ This document describes how to prepare a PR for a change in the main repository.
 - [Making changes in the Go code](#making-changes-in-the-go-code)
 - [Making changes in the Admin UI](#making-changes-in-the-admin-ui)
 
-
 ## Prerequisites
 
-- Go 1.18+ (for making changes in the Go code)
+- Go 1.19+ (for making changes in the Go code)
 - Node 16+ (for making changes in the Admin UI)
 
 If you haven't already, you can fork the main repository and clone your fork so that you can work locally:
+
 ```
 git clone https://github.com/your_username/pocketbase.git
 ```
 
+> [!IMPORTANT]
 > It is recommended to create a new branch from master for each of your bugfixes and features.
 > This is required if you are planning to submit multiple PRs in order to keep the changes separate for review until they eventually get merged.
 
-
 ## Making changes in the Go code
 
 PocketBase is distributed as a Go package, which means that in order to run the project you'll have to create a Go `main` program that imports the package.
 
-The repository already includes such program, located in `/examples/base`, that is also used for the prebuilt executables.
+The repository already includes such program, located in `examples/base`, that is also used for the prebuilt executables.
 
 So, let's assume that you already done some changes in the PocketBase Go code and you want now to run them:
 
@@ -41,20 +40,22 @@ This will start a web server on `http://localhost:8090` with the embedded prebui
 
 - Add unit/integration tests for your changes (we are using the standard `testing` go package).
   To run the tests, you could execute (while in the root project directory):
-    ```sh
-    go test ./...
 
-    # or using the Makefile
-    make test
-    ```
+  ```sh
+  go test ./...
+
+  # or using the Makefile
+  make test
+  ```
 
 - Run the linter - **golangci** ([see how to install](https://golangci-lint.run/usage/install/#local-installation)):
-    ```sh
-    golangci-lint run -c ./golangci.yml ./...
 
-    # or using the Makefile
-    make lint
-    ```
+  ```sh
+  golangci-lint run -c ./golangci.yml ./...
+
+  # or using the Makefile
+  make lint
+  ```
 
 ## Making changes in the Admin UI
 
@@ -65,14 +66,15 @@ To start the Admin UI:
 1. Navigate to the `ui` project directory
 2. Run `npm install` to install the node dependencies
 3. Start vite's dev server
-    ```sh
-    npm run dev
-    ```
+   ```sh
+   npm run dev
+   ```
 
 You could open the browser and access the running Admin UI at `http://localhost:3000`.
 
 Since the Admin UI is just a client-side application, you need to have the PocketBase backend server also running in the background (either manually running the `examples/base/main.go` or download a prebuilt executable).
 
+> [!NOTE]
 > By default, the Admin UI is expecting the backend server to be started at `http://localhost:8090`, but you could change that by creating a new `ui/.env.development.local` file with `PB_BACKEND_URL = YOUR_ADDRESS` variable inside it.
 
 Every change you make in the Admin UI should be automatically reflected in the browser at `http://localhost:3000` without reloading the page.

Makefile

@@ -4,6 +4,9 @@ lint:
 test:
 	go test ./... -v --cover
 
+jstypes:
+	go run ./plugins/jsvm/internal/types/types.go
+
 test-report:
 	go test ./... -v --cover -coverprofile=coverage.out
 	go tool cover -html=coverage.out

README.md

@@ -19,10 +19,10 @@
 
 **For documentation and examples, please visit https://pocketbase.io/docs.**
 
-> ⚠️ Please keep in mind that PocketBase is still under active development
+> [!WARNING]
+> Please keep in mind that PocketBase is still under active development
 > and therefore full backward compatibility is not guaranteed before reaching v1.0.0.
 
-
 ## API SDK clients
 
 The easiest way to interact with the API is to use one of the official SDK clients:
@@ -30,7 +30,6 @@ The easiest way to interact with the API is to use one of the official SDK clien
 - **JavaScript - [pocketbase/js-sdk](https://github.com/pocketbase/js-sdk)** (_browser and node_)
 - **Dart - [pocketbase/dart-sdk](https://github.com/pocketbase/dart-sdk)** (_web, mobile, desktop_)
 
-
 ## Overview
 
 PocketBase could be [downloaded directly as a standalone app](https://github.com/pocketbase/pocketbase/releases) or it could be used as a Go framework/toolkit which allows you to build
@@ -39,10 +38,9 @@ your own custom app specific business logic and still have a single portable exe
 ### Installation
 
 ```sh
-# go 1.18+
+# go 1.19+
 go get github.com/pocketbase/pocketbase
 ```
-> For Windows, you may have to use go 1.19+ due to an incorrect js mime type in the Windows Registry (see [issue#6](https://github.com/pocketbase/pocketbase/issues/6)).
 
 ### Example
 
@@ -95,14 +93,15 @@ Enable CGO only if you really need to squeeze the read/write query performance a
 
 To build the minimal standalone executable, like the prebuilt ones in the releases page, you can simply run `go build` inside the `examples/base` directory:
 
-0. [Install Go 1.18+](https://go.dev/doc/install) (_if you haven't already_)
+0. [Install Go 1.19+](https://go.dev/doc/install) (_if you haven't already_)
 1. Clone/download the repo
 2. Navigate to `examples/base`
 3. Run `GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build`
-    (_https://go.dev/doc/install/source#environment_)
+   (_https://go.dev/doc/install/source#environment_)
 4. Start the created executable by running `./base serve`.
 
 The supported build targets by the non-cgo driver at the moment are:
+
 ```
 darwin  amd64
 darwin  arm64
@@ -114,6 +113,7 @@ linux   arm
 linux   arm64
 linux   ppc64le
 linux   riscv64
+linux   s390x
 windows amd64
 windows arm64
 ```
@@ -122,6 +122,7 @@ windows arm64
 
 PocketBase comes with mixed bag of unit and integration tests.
 To run them, use the default `go test` command:
+
 ```sh
 go test ./...
 ```
@@ -134,7 +135,6 @@ If you discover a security vulnerability within PocketBase, please send an e-mai
 
 All reports will be promptly addressed, and you'll be credited accordingly.
 
-
 ## Contributing
 
 PocketBase is free and open source project licensed under the [MIT License](LICENSE.md).
@@ -146,14 +146,14 @@ You could help continuing its development by:
 - [Suggest new features and report issues](https://github.com/pocketbase/pocketbase/issues)
 - [Donate a small amount](https://pocketbase.io/support-us)
 
-PRs for _small features_ (eg. adding new OAuth2 providers), bug and documentation fixes, etc. are more than welcome.
+PRs for new OAuth2 providers, bug fixes, code optimizations and documentation improvements are more than welcome.
 
-But please refrain creating PRs for _big features_ without previously discussing the implementation details. Reviewing big PRs often requires a lot of time and tedious back-and-forth communication.
-PocketBase has a [roadmap](https://github.com/orgs/pocketbase/projects/2)
-and I try to work on issues in a specific order and such PRs often come in out of nowhere and skew all initial planning.
+But please refrain creating PRs for _new features_ without previously discussing the implementation details.
+PocketBase has a [roadmap](https://github.com/orgs/pocketbase/projects/2) and I try to work on issues in specific order and such PRs often come in out of nowhere and skew all initial planning with tedious back-and-forth communication.
 
 Don't get upset if I close your PR, even if it is well executed and tested. This doesn't mean that it will never be merged.
 Later we can always refer to it and/or take pieces of your implementation when the time comes to work on the issue (don't worry you'll be credited in the release notes).
 
-_Please also note that PocketBase was initially created to serve as a new backend for my other open source project - [Presentator](https://presentator.io) (see [#183](https://github.com/presentator/presentator/issues/183)),
-so all feature requests will be first aligned with what we need for Presentator v3._
+> [!NOTE]
+> PocketBase was initially created to serve as a new backend for my other open source project - [Presentator](https://presentator.io) (see [#183](https://github.com/presentator/presentator/issues/183)),
+> so all feature requests will be first aligned with what we need for Presentator v3.

apis/admin.go

@@ -33,18 +33,28 @@ type adminApi struct {
 	app core.App
 }
 
-func (api *adminApi) authResponse(c echo.Context, admin *models.Admin) error {
+func (api *adminApi) authResponse(c echo.Context, admin *models.Admin, finalizers ...func(token string) error) error {
 	token, tokenErr := tokens.NewAdminAuthToken(api.app, admin)
 	if tokenErr != nil {
 		return NewBadRequestError("Failed to create auth token.", tokenErr)
 	}
 
+	for _, f := range finalizers {
+		if err := f(token); err != nil {
+			return err
+		}
+	}
+
 	event := new(core.AdminAuthEvent)
 	event.HttpContext = c
 	event.Admin = admin
 	event.Token = token
 
 	return api.app.OnAdminAuthRequest().Trigger(event, func(e *core.AdminAuthEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		return e.HttpContext.JSON(200, map[string]any{
 			"token": e.Token,
 			"admin": e.Admin,
@@ -62,17 +72,11 @@ func (api *adminApi) authRefresh(c echo.Context) error {
 	event.HttpContext = c
 	event.Admin = admin
 
-	handlerErr := api.app.OnAdminBeforeAuthRefreshRequest().Trigger(event, func(e *core.AdminAuthRefreshEvent) error {
-		return api.authResponse(e.HttpContext, e.Admin)
+	return api.app.OnAdminBeforeAuthRefreshRequest().Trigger(event, func(e *core.AdminAuthRefreshEvent) error {
+		return api.app.OnAdminAfterAuthRefreshRequest().Trigger(event, func(e *core.AdminAuthRefreshEvent) error {
+			return api.authResponse(e.HttpContext, e.Admin)
+		})
 	})
-
-	if handlerErr == nil {
-		if err := api.app.OnAdminAfterAuthRefreshRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return handlerErr
 }
 
 func (api *adminApi) authWithPassword(c echo.Context) error {
@@ -95,17 +99,13 @@ func (api *adminApi) authWithPassword(c echo.Context) error {
 					return NewBadRequestError("Failed to authenticate.", err)
 				}
 
-				return api.authResponse(e.HttpContext, e.Admin)
+				return api.app.OnAdminAfterAuthWithPasswordRequest().Trigger(event, func(e *core.AdminAuthWithPasswordEvent) error {
+					return api.authResponse(e.HttpContext, e.Admin)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnAdminAfterAuthWithPasswordRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -130,29 +130,29 @@ func (api *adminApi) requestPasswordReset(c echo.Context) error {
 				// run in background because we don't need to show the result to the client
 				routine.FireAndForget(func() {
 					if err := next(e.Admin); err != nil && api.app.IsDebug() {
+						// @todo replace after logs generalization
 						log.Println(err)
 					}
 				})
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnAdminAfterRequestPasswordResetRequest().Trigger(event, func(e *core.AdminRequestPasswordResetEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnAdminAfterRequestPasswordResetRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	} else if api.app.IsDebug() {
-		log.Println(submitErr)
-	}
-
-	// don't return the response error to prevent emails enumeration
+	// eagerly write 204 response and skip submit errors
+	// as a measure against admins enumeration
 	if !c.Response().Committed {
 		c.NoContent(http.StatusNoContent)
 	}
 
-	return nil
+	return submitErr
 }
 
 func (api *adminApi) confirmPasswordReset(c echo.Context) error {
@@ -173,17 +173,17 @@ func (api *adminApi) confirmPasswordReset(c echo.Context) error {
 					return NewBadRequestError("Failed to set new password.", err)
 				}
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnAdminAfterConfirmPasswordResetRequest().Trigger(event, func(e *core.AdminConfirmPasswordResetEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnAdminAfterConfirmPasswordResetRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -208,6 +208,10 @@ func (api *adminApi) list(c echo.Context) error {
 	event.Result = result
 
 	return api.app.OnAdminsListRequest().Trigger(event, func(e *core.AdminsListEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		return e.HttpContext.JSON(http.StatusOK, e.Result)
 	})
 }
@@ -228,6 +232,10 @@ func (api *adminApi) view(c echo.Context) error {
 	event.Admin = admin
 
 	return api.app.OnAdminViewRequest().Trigger(event, func(e *core.AdminViewEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		return e.HttpContext.JSON(http.StatusOK, e.Admin)
 	})
 }
@@ -256,17 +264,17 @@ func (api *adminApi) create(c echo.Context) error {
 					return NewBadRequestError("Failed to create admin.", err)
 				}
 
-				return e.HttpContext.JSON(http.StatusOK, e.Admin)
+				return api.app.OnAdminAfterCreateRequest().Trigger(event, func(e *core.AdminCreateEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.JSON(http.StatusOK, e.Admin)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnAdminAfterCreateRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -302,17 +310,17 @@ func (api *adminApi) update(c echo.Context) error {
 					return NewBadRequestError("Failed to update admin.", err)
 				}
 
-				return e.HttpContext.JSON(http.StatusOK, e.Admin)
+				return api.app.OnAdminAfterUpdateRequest().Trigger(event, func(e *core.AdminUpdateEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.JSON(http.StatusOK, e.Admin)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnAdminAfterUpdateRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -331,19 +339,17 @@ func (api *adminApi) delete(c echo.Context) error {
 	event.HttpContext = c
 	event.Admin = admin
 
-	handlerErr := api.app.OnAdminBeforeDeleteRequest().Trigger(event, func(e *core.AdminDeleteEvent) error {
+	return api.app.OnAdminBeforeDeleteRequest().Trigger(event, func(e *core.AdminDeleteEvent) error {
 		if err := api.app.Dao().DeleteAdmin(e.Admin); err != nil {
 			return NewBadRequestError("Failed to delete admin.", err)
 		}
 
-		return e.HttpContext.NoContent(http.StatusNoContent)
+		return api.app.OnAdminAfterDeleteRequest().Trigger(event, func(e *core.AdminDeleteEvent) error {
+			if e.HttpContext.Response().Committed {
+				return nil
+			}
+
+			return e.HttpContext.NoContent(http.StatusNoContent)
+		})
 	})
-
-	if handlerErr == nil {
-		if err := api.app.OnAdminAfterDeleteRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return handlerErr
 }

apis/admin_test.go

@@ -1,6 +1,7 @@
 package apis_test
 
 import (
+	"errors"
 	"net/http"
 	"strings"
 	"testing"
@@ -8,6 +9,7 @@ import (
 
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/tests"
@@ -89,6 +91,26 @@ func TestAdminAuthWithPassword(t *testing.T) {
 				"OnAdminAuthRequest":                   1,
 			},
 		},
+		{
+			Name:   "OnAdminAfterAuthWithPasswordRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/admins/auth-with-password",
+			Body:   strings.NewReader(`{"identity":"test@example.com","password":"1234567890"}`),
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4MTYwMH0.han3_sG65zLddpcX2ic78qgy7FKecuPfOpFa8Dvi5Bg",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnAdminAfterAuthWithPasswordRequest().Add(func(e *core.AdminAuthWithPasswordEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnAdminBeforeAuthWithPasswordRequest": 1,
+				"OnAdminAfterAuthWithPasswordRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -224,6 +246,29 @@ func TestAdminConfirmPasswordReset(t *testing.T) {
 				"OnAdminAfterConfirmPasswordResetRequest":  1,
 			},
 		},
+		{
+			Name:   "OnAdminAfterConfirmPasswordResetRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/admins/confirm-password-reset",
+			Body: strings.NewReader(`{
+				"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImVtYWlsIjoidGVzdEBleGFtcGxlLmNvbSIsImV4cCI6MjIwODk4MTYwMH0.kwFEler6KSMKJNstuaSDvE1QnNdCta5qSnjaIQ0hhhc",
+				"password":"1234567891",
+				"passwordConfirm":"1234567891"
+			}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnAdminAfterConfirmPasswordResetRequest().Add(func(e *core.AdminConfirmPasswordResetEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelBeforeUpdate":                      1,
+				"OnModelAfterUpdate":                       1,
+				"OnAdminBeforeConfirmPasswordResetRequest": 1,
+				"OnAdminAfterConfirmPasswordResetRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -278,6 +323,25 @@ func TestAdminRefresh(t *testing.T) {
 				"OnAdminAfterAuthRefreshRequest":  1,
 			},
 		},
+		{
+			Name:   "OnAdminAfterAuthRefreshRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/admins/auth-refresh",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnAdminAfterAuthRefreshRequest().Add(func(e *core.AdminAuthRefreshEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnAdminBeforeAuthRefreshRequest": 1,
+				"OnAdminAfterAuthRefreshRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -510,6 +574,27 @@ func TestAdminDelete(t *testing.T) {
 				"OnAdminBeforeDeleteRequest": 1,
 			},
 		},
+		{
+			Name:   "OnAdminAfterDeleteRequest error response",
+			Method: http.MethodDelete,
+			Url:    "/api/admins/sbmbsdb40jyxf7h",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnAdminAfterDeleteRequest().Add(func(e *core.AdminDeleteEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelBeforeDelete":        1,
+				"OnModelAfterDelete":         1,
+				"OnAdminBeforeDeleteRequest": 1,
+				"OnAdminAfterDeleteRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -637,6 +722,33 @@ func TestAdminCreate(t *testing.T) {
 				"OnAdminAfterCreateRequest":  1,
 			},
 		},
+		{
+			Name:   "OnAdminAfterCreateRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/admins",
+			Body: strings.NewReader(`{
+				"email":"testnew@example.com",
+				"password":"1234567890",
+				"passwordConfirm":"1234567890",
+				"avatar":3
+			}`),
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnAdminAfterCreateRequest().Add(func(e *core.AdminCreateEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelBeforeCreate":        1,
+				"OnModelAfterCreate":         1,
+				"OnAdminBeforeCreateRequest": 1,
+				"OnAdminAfterCreateRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -729,6 +841,7 @@ func TestAdminUpdate(t *testing.T) {
 			},
 		},
 		{
+			Name:   "authorized as admin + valid data",
 			Method: http.MethodPatch,
 			Url:    "/api/admins/sbmbsdb40jyxf7h",
 			Body: strings.NewReader(`{
@@ -759,6 +872,33 @@ func TestAdminUpdate(t *testing.T) {
 				"OnAdminAfterUpdateRequest":  1,
 			},
 		},
+		{
+			Name:   "OnAdminAfterUpdateRequest error response",
+			Method: http.MethodPatch,
+			Url:    "/api/admins/sbmbsdb40jyxf7h",
+			Body: strings.NewReader(`{
+				"email":"testnew@example.com",
+				"password":"1234567891",
+				"passwordConfirm":"1234567891",
+				"avatar":5
+			}`),
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnAdminAfterUpdateRequest().Add(func(e *core.AdminUpdateEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelBeforeUpdate":        1,
+				"OnModelAfterUpdate":         1,
+				"OnAdminBeforeUpdateRequest": 1,
+				"OnAdminAfterUpdateRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {

apis/api_error.go

@@ -66,43 +66,67 @@ func NewUnauthorizedError(message string, data any) *ApiError {
 
 // NewApiError creates and returns new normalized `ApiError` instance.
 func NewApiError(status int, message string, data any) *ApiError {
-	message = inflector.Sentenize(message)
-
-	formattedData := map[string]any{}
-
-	if v, ok := data.(validation.Errors); ok {
-		formattedData = resolveValidationErrors(v)
-	}
-
 	return &ApiError{
 		rawData: data,
-		Data:    formattedData,
+		Data:    safeErrorsData(data),
 		Code:    status,
-		Message: strings.TrimSpace(message),
+		Message: strings.TrimSpace(inflector.Sentenize(message)),
 	}
 }
 
-func resolveValidationErrors(validationErrors validation.Errors) map[string]any {
+func safeErrorsData(data any) map[string]any {
+	switch v := data.(type) {
+	case validation.Errors:
+		return resolveSafeErrorsData[error](v)
+	case map[string]validation.Error:
+		return resolveSafeErrorsData[validation.Error](v)
+	case map[string]error:
+		return resolveSafeErrorsData[error](v)
+	case map[string]any:
+		return resolveSafeErrorsData[any](v)
+	default:
+		return map[string]any{} // not nil to ensure that is json serialized as object
+	}
+}
+
+func resolveSafeErrorsData[T any](data map[string]T) map[string]any {
 	result := map[string]any{}
 
-	// extract from each validation error its error code and message.
-	for name, err := range validationErrors {
-		// check for nested errors
-		if nestedErrs, ok := err.(validation.Errors); ok {
-			result[name] = resolveValidationErrors(nestedErrs)
+	for name, err := range data {
+		if isNestedError(err) {
+			result[name] = safeErrorsData(err)
 			continue
 		}
-
-		errCode := "validation_invalid_value" // default
-		if errObj, ok := err.(validation.ErrorObject); ok {
-			errCode = errObj.Code()
-		}
-
-		result[name] = map[string]string{
-			"code":    errCode,
-			"message": inflector.Sentenize(err.Error()),
-		}
+		result[name] = resolveSafeErrorItem(err)
 	}
 
 	return result
 }
+
+func isNestedError(err any) bool {
+	switch err.(type) {
+	case validation.Errors, map[string]validation.Error, map[string]error, map[string]any:
+		return true
+	}
+
+	return false
+}
+
+// resolveSafeErrorItem extracts from each validation error its
+// public safe error code and message.
+func resolveSafeErrorItem(err any) map[string]string {
+	// default public safe error values
+	code := "validation_invalid_value"
+	msg := "Invalid value."
+
+	// only validation errors are public safe
+	if obj, ok := err.(validation.Error); ok {
+		code = obj.Code()
+		msg = inflector.Sentenize(obj.Error())
+	}
+
+	return map[string]string{
+		"code":    code,
+		"message": msg,
+	}
+}

apis/api_error_test.go

@@ -37,10 +37,10 @@ func TestNewApiErrorWithValidationData(t *testing.T) {
 		300,
 		"message_test",
 		validation.Errors{
-			"err1": errors.New("test error"),
+			"err1": errors.New("test error"), // should be normalized
 			"err2": validation.ErrRequired,
 			"err3": validation.Errors{
-				"sub1": errors.New("test error"),
+				"sub1": errors.New("test error"), // should be normalized
 				"sub2": validation.ErrRequired,
 				"sub3": validation.Errors{
 					"sub11": validation.ErrRequired,
@@ -50,10 +50,10 @@ func TestNewApiErrorWithValidationData(t *testing.T) {
 	)
 
 	result, _ := json.Marshal(e)
-	expected := `{"code":300,"message":"Message_test.","data":{"err1":{"code":"validation_invalid_value","message":"Test error."},"err2":{"code":"validation_required","message":"Cannot be blank."},"err3":{"sub1":{"code":"validation_invalid_value","message":"Test error."},"sub2":{"code":"validation_required","message":"Cannot be blank."},"sub3":{"sub11":{"code":"validation_required","message":"Cannot be blank."}}}}}`
+	expected := `{"code":300,"message":"Message_test.","data":{"err1":{"code":"validation_invalid_value","message":"Invalid value."},"err2":{"code":"validation_required","message":"Cannot be blank."},"err3":{"sub1":{"code":"validation_invalid_value","message":"Invalid value."},"sub2":{"code":"validation_required","message":"Cannot be blank."},"sub3":{"sub11":{"code":"validation_required","message":"Cannot be blank."}}}}}`
 
 	if string(result) != expected {
-		t.Errorf("Expected %v, got %v", expected, string(result))
+		t.Errorf("Expected \n%v, \ngot \n%v", expected, string(result))
 	}
 
 	if e.Error() != "Message_test." {
@@ -73,7 +73,7 @@ func TestNewNotFoundError(t *testing.T) {
 	}{
 		{"", nil, `{"code":404,"message":"The requested resource wasn't found.","data":{}}`},
 		{"demo", "rawData_test", `{"code":404,"message":"Demo.","data":{}}`},
-		{"demo", validation.Errors{"err1": errors.New("test error")}, `{"code":404,"message":"Demo.","data":{"err1":{"code":"validation_invalid_value","message":"Test error."}}}`},
+		{"demo", validation.Errors{"err1": validation.NewError("test_code", "test_message")}, `{"code":404,"message":"Demo.","data":{"err1":{"code":"test_code","message":"Test_message."}}}`},
 	}
 
 	for i, scenario := range scenarios {
@@ -81,7 +81,7 @@ func TestNewNotFoundError(t *testing.T) {
 		result, _ := json.Marshal(e)
 
 		if string(result) != scenario.expected {
-			t.Errorf("(%d) Expected %v, got %v", i, scenario.expected, string(result))
+			t.Errorf("(%d) Expected \n%v, \ngot \n%v", i, scenario.expected, string(result))
 		}
 	}
 }
@@ -94,7 +94,7 @@ func TestNewBadRequestError(t *testing.T) {
 	}{
 		{"", nil, `{"code":400,"message":"Something went wrong while processing your request.","data":{}}`},
 		{"demo", "rawData_test", `{"code":400,"message":"Demo.","data":{}}`},
-		{"demo", validation.Errors{"err1": errors.New("test error")}, `{"code":400,"message":"Demo.","data":{"err1":{"code":"validation_invalid_value","message":"Test error."}}}`},
+		{"demo", validation.Errors{"err1": validation.NewError("test_code", "test_message")}, `{"code":400,"message":"Demo.","data":{"err1":{"code":"test_code","message":"Test_message."}}}`},
 	}
 
 	for i, scenario := range scenarios {
@@ -102,7 +102,7 @@ func TestNewBadRequestError(t *testing.T) {
 		result, _ := json.Marshal(e)
 
 		if string(result) != scenario.expected {
-			t.Errorf("(%d) Expected %v, got %v", i, scenario.expected, string(result))
+			t.Errorf("(%d) Expected \n%v, \ngot \n%v", i, scenario.expected, string(result))
 		}
 	}
 }
@@ -115,7 +115,7 @@ func TestNewForbiddenError(t *testing.T) {
 	}{
 		{"", nil, `{"code":403,"message":"You are not allowed to perform this request.","data":{}}`},
 		{"demo", "rawData_test", `{"code":403,"message":"Demo.","data":{}}`},
-		{"demo", validation.Errors{"err1": errors.New("test error")}, `{"code":403,"message":"Demo.","data":{"err1":{"code":"validation_invalid_value","message":"Test error."}}}`},
+		{"demo", validation.Errors{"err1": validation.NewError("test_code", "test_message")}, `{"code":403,"message":"Demo.","data":{"err1":{"code":"test_code","message":"Test_message."}}}`},
 	}
 
 	for i, scenario := range scenarios {
@@ -123,7 +123,7 @@ func TestNewForbiddenError(t *testing.T) {
 		result, _ := json.Marshal(e)
 
 		if string(result) != scenario.expected {
-			t.Errorf("(%d) Expected %v, got %v", i, scenario.expected, string(result))
+			t.Errorf("(%d) Expected \n%v, \ngot \n%v", i, scenario.expected, string(result))
 		}
 	}
 }
@@ -136,7 +136,7 @@ func TestNewUnauthorizedError(t *testing.T) {
 	}{
 		{"", nil, `{"code":401,"message":"Missing or invalid authentication token.","data":{}}`},
 		{"demo", "rawData_test", `{"code":401,"message":"Demo.","data":{}}`},
-		{"demo", validation.Errors{"err1": errors.New("test error")}, `{"code":401,"message":"Demo.","data":{"err1":{"code":"validation_invalid_value","message":"Test error."}}}`},
+		{"demo", validation.Errors{"err1": validation.NewError("test_code", "test_message")}, `{"code":401,"message":"Demo.","data":{"err1":{"code":"test_code","message":"Test_message."}}}`},
 	}
 
 	for i, scenario := range scenarios {
@@ -144,7 +144,7 @@ func TestNewUnauthorizedError(t *testing.T) {
 		result, _ := json.Marshal(e)
 
 		if string(result) != scenario.expected {
-			t.Errorf("(%d) Expected %v, got %v", i, scenario.expected, string(result))
+			t.Errorf("(%d) Expected \n%v, \ngot \n%v", i, scenario.expected, string(result))
 		}
 	}
 }

apis/backup.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"log"
 	"net/http"
-	"net/url"
 	"path/filepath"
 	"time"
 
@@ -12,6 +11,8 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/forms"
 	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+	"github.com/pocketbase/pocketbase/tools/rest"
 	"github.com/pocketbase/pocketbase/tools/types"
 	"github.com/spf13/cast"
 )
@@ -25,6 +26,7 @@ func bindBackupApi(app core.App, rg *echo.Group) {
 	subGroup := rg.Group("/backups", ActivityLogger(app))
 	subGroup.GET("", api.list, RequireAdminAuth())
 	subGroup.POST("", api.create, RequireAdminAuth())
+	subGroup.POST("/upload", api.upload, RequireAdminAuth())
 	subGroup.GET("/:key", api.download)
 	subGroup.DELETE("/:key", api.delete, RequireAdminAuth())
 	subGroup.POST("/:key/restore", api.restore, RequireAdminAuth())
@@ -89,6 +91,28 @@ func (api *backupApi) create(c echo.Context) error {
 	})
 }
 
+func (api *backupApi) upload(c echo.Context) error {
+	files, err := rest.FindUploadedFiles(c.Request(), "file")
+	if err != nil {
+		return NewBadRequestError("Missing or invalid uploaded file.", err)
+	}
+
+	form := forms.NewBackupUpload(api.app)
+	form.File = files[0]
+
+	return form.Submit(func(next forms.InterceptorNextFunc[*filesystem.File]) forms.InterceptorNextFunc[*filesystem.File] {
+		return func(file *filesystem.File) error {
+			if err := next(file); err != nil {
+				return NewBadRequestError("Failed to upload backup.", err)
+			}
+
+			// we don't retrieve the generated backup file because it may not be
+			// available yet due to the eventually consistent nature of some S3 providers
+			return c.NoContent(http.StatusNoContent)
+		}
+	})
+}
+
 func (api *backupApi) download(c echo.Context) error {
 	fileToken := c.QueryParam("token")
 
@@ -132,8 +156,7 @@ func (api *backupApi) restore(c echo.Context) error {
 		return NewBadRequestError("Try again later - another backup/restore process has already been started.", nil)
 	}
 
-	// @todo remove the extra unescape after https://github.com/labstack/echo/issues/2447
-	key, _ := url.PathUnescape(c.PathParam("key"))
+	key := c.PathParam("key")
 
 	existsCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()

apis/backup_test.go

@@ -1,7 +1,11 @@
 package apis_test
 
 import (
+	"archive/zip"
+	"bytes"
 	"context"
+	"io"
+	"mime/multipart"
 	"net/http"
 	"strings"
 	"testing"
@@ -85,7 +89,7 @@ func TestBackupsCreate(t *testing.T) {
 			Name:   "unauthorized",
 			Method: http.MethodPost,
 			Url:    "/api/backups",
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				ensureNoBackups(t, app)
 			},
 			ExpectedStatus:  401,
@@ -98,7 +102,7 @@ func TestBackupsCreate(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjRxMXhsY2xtZmxva3UzMyIsInR5cGUiOiJhdXRoUmVjb3JkIiwiY29sbGVjdGlvbklkIjoiX3BiX3VzZXJzX2F1dGhfIiwiZXhwIjoyMjA4OTg1MjYxfQ.UwD8JvkbQtXpymT09d7J6fdA0aP9g4FJ1GPh_ggEkzc",
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				ensureNoBackups(t, app)
 			},
 			ExpectedStatus:  401,
@@ -114,7 +118,7 @@ func TestBackupsCreate(t *testing.T) {
 			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
 				app.Cache().Set(core.CacheKeyActiveBackup, "")
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				ensureNoBackups(t, app)
 			},
 			ExpectedStatus:  400,
@@ -127,7 +131,7 @@ func TestBackupsCreate(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				files, err := getBackupFiles(app)
 				if err != nil {
 					t.Fatal(err)
@@ -152,7 +156,7 @@ func TestBackupsCreate(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				ensureNoBackups(t, app)
 			},
 			ExpectedStatus: 400,
@@ -169,7 +173,7 @@ func TestBackupsCreate(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				files, err := getBackupFiles(app)
 				if err != nil {
 					t.Fatal(err)
@@ -193,6 +197,138 @@ func TestBackupsCreate(t *testing.T) {
 	}
 }
 
+func TestBackupsUpload(t *testing.T) {
+	// create dummy form data bodies
+	type body struct {
+		buffer      io.Reader
+		contentType string
+	}
+	bodies := make([]body, 10)
+	for i := 0; i < 10; i++ {
+		func() {
+			zb := new(bytes.Buffer)
+			zw := zip.NewWriter(zb)
+			if err := zw.Close(); err != nil {
+				t.Fatal(err)
+			}
+
+			b := new(bytes.Buffer)
+			mw := multipart.NewWriter(b)
+
+			mfw, err := mw.CreateFormFile("file", "test")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := io.Copy(mfw, zb); err != nil {
+				t.Fatal(err)
+			}
+
+			mw.Close()
+
+			bodies[i] = body{
+				buffer:      b,
+				contentType: mw.FormDataContentType(),
+			}
+		}()
+	}
+	// ---
+
+	scenarios := []tests.ApiScenario{
+		{
+			Name:   "unauthorized",
+			Method: http.MethodPost,
+			Url:    "/api/backups/upload",
+			Body:   bodies[0].buffer,
+			RequestHeaders: map[string]string{
+				"Content-Type": bodies[0].contentType,
+			},
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
+				ensureNoBackups(t, app)
+			},
+			ExpectedStatus:  401,
+			ExpectedContent: []string{`"data":{}`},
+		},
+		{
+			Name:   "authorized as auth record",
+			Method: http.MethodPost,
+			Url:    "/api/backups/upload",
+			Body:   bodies[1].buffer,
+			RequestHeaders: map[string]string{
+				"Content-Type":  bodies[1].contentType,
+				"Authorization": "eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjRxMXhsY2xtZmxva3UzMyIsInR5cGUiOiJhdXRoUmVjb3JkIiwiY29sbGVjdGlvbklkIjoiX3BiX3VzZXJzX2F1dGhfIiwiZXhwIjoyMjA4OTg1MjYxfQ.UwD8JvkbQtXpymT09d7J6fdA0aP9g4FJ1GPh_ggEkzc",
+			},
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
+				ensureNoBackups(t, app)
+			},
+			ExpectedStatus:  401,
+			ExpectedContent: []string{`"data":{}`},
+		},
+		{
+			Name:   "authorized as admin (missing file)",
+			Method: http.MethodPost,
+			Url:    "/api/backups/upload",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
+				ensureNoBackups(t, app)
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{`},
+		},
+		{
+			Name:   "authorized as admin (existing backup name)",
+			Method: http.MethodPost,
+			Url:    "/api/backups/upload",
+			Body:   bodies[3].buffer,
+			RequestHeaders: map[string]string{
+				"Content-Type":  bodies[3].contentType,
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				fsys, err := app.NewBackupsFilesystem()
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer fsys.Close()
+				// create a dummy backup file to simulate existing backups
+				if err := fsys.Upload([]byte("123"), "test"); err != nil {
+					t.Fatal(err)
+				}
+			},
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
+				files, _ := getBackupFiles(app)
+				if total := len(files); total != 1 {
+					t.Fatalf("Expected %d backup file, got %d", 1, total)
+				}
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{"file":{`},
+		},
+		{
+			Name:   "authorized as admin (valid file)",
+			Method: http.MethodPost,
+			Url:    "/api/backups/upload",
+			Body:   bodies[4].buffer,
+			RequestHeaders: map[string]string{
+				"Content-Type":  bodies[4].contentType,
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
+				files, _ := getBackupFiles(app)
+				if total := len(files); total != 1 {
+					t.Fatalf("Expected %d backup file, got %d", 1, total)
+				}
+			},
+			ExpectedStatus: 204,
+		},
+	}
+
+	for _, scenario := range scenarios {
+		scenario.Test(t)
+	}
+}
+
 func TestBackupsDownload(t *testing.T) {
 	scenarios := []tests.ApiScenario{
 		{
@@ -300,7 +436,7 @@ func TestBackupsDownload(t *testing.T) {
 		{
 			Name:   "with valid admin file token but missing backup name",
 			Method: http.MethodGet,
-			Url:    "/api/backups/mizzing?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsImV4cCI6MTg5MzQ1MjQ2MSwidHlwZSI6ImFkbWluIn0.LyAMpSfaHVsuUqIlqqEbhDQSdFzoPz_EIDcb2VJMBsU",
+			Url:    "/api/backups/missing?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsImV4cCI6MTg5MzQ1MjQ2MSwidHlwZSI6ImFkbWluIn0.LyAMpSfaHVsuUqIlqqEbhDQSdFzoPz_EIDcb2VJMBsU",
 			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
 				if err := createTestBackups(app); err != nil {
 					t.Fatal(err)
@@ -325,6 +461,22 @@ func TestBackupsDownload(t *testing.T) {
 				`logs.db`,
 			},
 		},
+		{
+			Name:   "with valid admin file token and backup name with escaped char",
+			Method: http.MethodGet,
+			Url:    "/api/backups/%40test4.zip?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsImV4cCI6MTg5MzQ1MjQ2MSwidHlwZSI6ImFkbWluIn0.LyAMpSfaHVsuUqIlqqEbhDQSdFzoPz_EIDcb2VJMBsU",
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				if err := createTestBackups(app); err != nil {
+					t.Fatal(err)
+				}
+			},
+			ExpectedStatus: 200,
+			ExpectedContent: []string{
+				`storage/`,
+				`data.db`,
+				`logs.db`,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -339,7 +491,7 @@ func TestBackupsDelete(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		expected := 3
+		expected := 4
 		if total := len(files); total != expected {
 			t.Fatalf("Expected %d backup(s), got %d", expected, total)
 		}
@@ -355,7 +507,7 @@ func TestBackupsDelete(t *testing.T) {
 					t.Fatal(err)
 				}
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				noTestBackupFilesChanges(t, app)
 			},
 			ExpectedStatus:  401,
@@ -373,7 +525,7 @@ func TestBackupsDelete(t *testing.T) {
 					t.Fatal(err)
 				}
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				noTestBackupFilesChanges(t, app)
 			},
 			ExpectedStatus:  401,
@@ -391,7 +543,7 @@ func TestBackupsDelete(t *testing.T) {
 					t.Fatal(err)
 				}
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				noTestBackupFilesChanges(t, app)
 			},
 			ExpectedStatus:  400,
@@ -411,9 +563,8 @@ func TestBackupsDelete(t *testing.T) {
 
 				// mock active backup with the same name to delete
 				app.Cache().Set(core.CacheKeyActiveBackup, "test1.zip")
-
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				noTestBackupFilesChanges(t, app)
 			},
 			ExpectedStatus:  400,
@@ -434,14 +585,14 @@ func TestBackupsDelete(t *testing.T) {
 				// mock active backup with different name
 				app.Cache().Set(core.CacheKeyActiveBackup, "new.zip")
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				files, err := getBackupFiles(app)
 				if err != nil {
 					t.Fatal(err)
 				}
 
-				if total := len(files); total != 2 {
-					t.Fatalf("Expected 2 backup files, got %d", total)
+				if total := len(files); total != 3 {
+					t.Fatalf("Expected %d backup files, got %d", 3, total)
 				}
 
 				deletedFile := "test1.zip"
@@ -454,6 +605,38 @@ func TestBackupsDelete(t *testing.T) {
 			},
 			ExpectedStatus: 204,
 		},
+		{
+			Name:   "authorized as admin (backup with escaped character)",
+			Method: http.MethodDelete,
+			Url:    "/api/backups/%40test4.zip",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				if err := createTestBackups(app); err != nil {
+					t.Fatal(err)
+				}
+			},
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
+				files, err := getBackupFiles(app)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				if total := len(files); total != 3 {
+					t.Fatalf("Expected %d backup files, got %d", 3, total)
+				}
+
+				deletedFile := "@test4.zip"
+
+				for _, f := range files {
+					if f.Key == deletedFile {
+						t.Fatalf("Expected backup %q to be deleted", deletedFile)
+					}
+				}
+			},
+			ExpectedStatus: 204,
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -546,6 +729,10 @@ func createTestBackups(app core.App) error {
 		return err
 	}
 
+	if err := app.CreateBackup(ctx, "@test4.zip"); err != nil {
+		return err
+	}
+
 	return nil
 }
 

apis/base.go

@@ -2,6 +2,7 @@
 package apis
 
 import (
+	"database/sql"
 	"errors"
 	"fmt"
 	"io/fs"
@@ -34,6 +35,7 @@ func InitApi(app core.App) (*echo.Echo, error) {
 	e.ResetRouterCreator(func(ec *echo.Echo) echo.Router {
 		return echo.NewRouter(echo.RouterConfig{
 			UnescapePathParamValues: true,
+			AllowOverwritingRoute:   true,
 		})
 	})
 
@@ -44,12 +46,16 @@ func InitApi(app core.App) (*echo.Echo, error) {
 			return !strings.HasPrefix(c.Request().URL.Path, "/api/")
 		},
 	}))
+	e.Pre(LoadAuthContext(app))
 	e.Use(middleware.Recover())
 	e.Use(middleware.Secure())
-	e.Use(LoadAuthContext(app))
 
 	// custom error handler
 	e.HTTPErrorHandler = func(c echo.Context, err error) {
+		if err == nil {
+			return // no error
+		}
+
 		if c.Response().Committed {
 			if app.IsDebug() {
 				log.Println("HTTPErrorHandler response was already committed:", err)
@@ -59,23 +65,26 @@ func InitApi(app core.App) (*echo.Echo, error) {
 
 		var apiErr *ApiError
 
-		switch v := err.(type) {
-		case *echo.HTTPError:
+		if errors.As(err, &apiErr) {
+			if app.IsDebug() && apiErr.RawData() != nil {
+				log.Println(apiErr.RawData())
+			}
+		} else if v := new(echo.HTTPError); errors.As(err, &v) {
 			if v.Internal != nil && app.IsDebug() {
 				log.Println(v.Internal)
 			}
 			msg := fmt.Sprintf("%v", v.Message)
 			apiErr = NewApiError(v.Code, msg, v)
-		case *ApiError:
-			if app.IsDebug() && v.RawData() != nil {
-				log.Println(v.RawData())
-			}
-			apiErr = v
-		default:
-			if err != nil && app.IsDebug() {
+		} else {
+			if app.IsDebug() {
 				log.Println(err)
 			}
-			apiErr = NewBadRequestError("", err)
+
+			if errors.Is(err, sql.ErrNoRows) {
+				apiErr = NewNotFoundError("", err)
+			} else {
+				apiErr = NewBadRequestError("", err)
+			}
 		}
 
 		event := new(core.ApiErrorEvent)
@@ -84,6 +93,10 @@ func InitApi(app core.App) (*echo.Echo, error) {
 
 		// send error response
 		hookErr := app.OnBeforeApiError().Trigger(event, func(e *core.ApiErrorEvent) error {
+			if c.Response().Committed {
+				return nil
+			}
+
 			// @see https://github.com/labstack/echo/issues/608
 			if e.HttpContext.Request().Method == http.MethodHead {
 				return e.HttpContext.NoContent(apiErr.Code)
@@ -92,19 +105,21 @@ func InitApi(app core.App) (*echo.Echo, error) {
 			return e.HttpContext.JSON(apiErr.Code, apiErr)
 		})
 
-		// truly rare case; eg. client already disconnected
-		if hookErr != nil && app.IsDebug() {
+		if hookErr == nil {
+			if err := app.OnAfterApiError().Trigger(event); err != nil && app.IsDebug() {
+				log.Println(hookErr)
+			}
+		} else if app.IsDebug() {
+			// truly rare case; eg. client already disconnected
 			log.Println(hookErr)
 		}
-
-		app.OnAfterApiError().Trigger(event)
 	}
 
 	// admin ui routes
 	bindStaticAdminUI(app, e)
 
 	// default routes
-	api := e.Group("/api")
+	api := e.Group("/api", eagerRequestInfoCache(app))
 	bindSettingsApi(app, api)
 	bindAdminApi(app, api)
 	bindCollectionApi(app, api)
@@ -116,20 +131,6 @@ func InitApi(app core.App) (*echo.Echo, error) {
 	bindHealthApi(app, api)
 	bindBackupApi(app, api)
 
-	// trigger the custom BeforeServe hook for the created api router
-	// allowing users to further adjust its options or register new routes
-	serveEvent := &core.ServeEvent{
-		App:    app,
-		Router: e,
-	}
-	if err := app.OnBeforeServe().Trigger(serveEvent); err != nil {
-		return nil, err
-	}
-
-	// note: it is after the OnBeforeServe hook to ensure that the implicit
-	// cache is after any user custom defined middlewares
-	e.Use(eagerRequestDataCache(app))
-
 	// catch all any route
 	api.Any("/*", func(c echo.Context) error {
 		return echo.ErrNotFound
@@ -192,19 +193,6 @@ func bindStaticAdminUI(app core.App, e *echo.Echo) error {
 	return nil
 }
 
-const totalAdminsCacheKey = "@totalAdmins"
-
-func updateTotalAdminsCache(app core.App) error {
-	total, err := app.Dao().TotalAdmins()
-	if err != nil {
-		return err
-	}
-
-	app.Cache().Set(totalAdminsCacheKey, total)
-
-	return nil
-}
-
 func uiCacheControl() echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
@@ -219,15 +207,29 @@ func uiCacheControl() echo.MiddlewareFunc {
 	}
 }
 
+const hasAdminsCacheKey = "@hasAdmins"
+
+func updateHasAdminsCache(app core.App) error {
+	total, err := app.Dao().TotalAdmins()
+	if err != nil {
+		return err
+	}
+
+	app.Cache().Set(hasAdminsCacheKey, total > 0)
+
+	return nil
+}
+
 // installerRedirect redirects the user to the installer admin UI page
 // when the application needs some preliminary configurations to be done.
 func installerRedirect(app core.App) echo.MiddlewareFunc {
-	// keep totalAdminsCacheKey value up-to-date
+	// keep hasAdminsCacheKey value up-to-date
 	app.OnAdminAfterCreateRequest().Add(func(data *core.AdminCreateEvent) error {
-		return updateTotalAdminsCache(app)
+		return updateHasAdminsCache(app)
 	})
+
 	app.OnAdminAfterDeleteRequest().Add(func(data *core.AdminDeleteEvent) error {
-		return updateTotalAdminsCache(app)
+		return updateHasAdminsCache(app)
 	})
 
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
@@ -238,23 +240,24 @@ func installerRedirect(app core.App) echo.MiddlewareFunc {
 				return next(c)
 			}
 
-			// load into cache (if not already)
-			if !app.Cache().Has(totalAdminsCacheKey) {
-				if err := updateTotalAdminsCache(app); err != nil {
+			hasAdmins := cast.ToBool(app.Cache().Get(hasAdminsCacheKey))
+
+			if !hasAdmins {
+				// update the cache to make sure that the admin wasn't created by another process
+				if err := updateHasAdminsCache(app); err != nil {
 					return err
 				}
+				hasAdmins = cast.ToBool(app.Cache().Get(hasAdminsCacheKey))
 			}
 
-			totalAdmins := cast.ToInt(app.Cache().Get(totalAdminsCacheKey))
-
 			_, hasInstallerParam := c.Request().URL.Query()["installer"]
 
-			if totalAdmins == 0 && !hasInstallerParam {
+			if !hasAdmins && !hasInstallerParam {
 				// redirect to the installer page
 				return c.Redirect(http.StatusTemporaryRedirect, "?installer#")
 			}
 
-			if totalAdmins != 0 && hasInstallerParam {
+			if hasAdmins && hasInstallerParam {
 				// clear the installer param
 				return c.Redirect(http.StatusTemporaryRedirect, "?")
 			}

apis/base_test.go

@@ -1,6 +1,7 @@
 package apis_test
 
 import (
+	"database/sql"
 	"errors"
 	"fmt"
 	"net/http"
@@ -213,16 +214,16 @@ func TestRemoveTrailingSlashMiddleware(t *testing.T) {
 	}
 }
 
-func TestEagerRequestDataCache(t *testing.T) {
+func TestEagerRequestInfoCache(t *testing.T) {
 	scenarios := []tests.ApiScenario{
 		{
-			Name:   "[UNKNOWN] unsupported eager cached request method",
-			Method: "UNKNOWN",
+			Name:   "custom non-api group route",
+			Method: "POST",
 			Url:    "/custom",
 			Body:   strings.NewReader(`{"name":"test123"}`),
 			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
 				e.AddRoute(echo.Route{
-					Method: "UNKNOWN",
+					Method: "POST",
 					Path:   "/custom",
 					Handler: func(c echo.Context) error {
 						data := &struct {
@@ -235,57 +236,163 @@ func TestEagerRequestDataCache(t *testing.T) {
 
 						// since the unknown method is not eager cache support
 						// it should fail reading the json body twice
-						r := apis.RequestData(c)
+						r := apis.RequestInfo(c)
 						if v := cast.ToString(r.Data["name"]); v != "" {
 							t.Fatalf("Expected empty request data body, got, %v", r.Data)
 						}
 
-						return c.String(200, data.Name)
+						return c.NoContent(200)
 					},
 				})
 			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"test123"},
+			ExpectedStatus: 200,
 		},
-	}
+		{
+			Name:   "api group route with unsupported eager cache request method",
+			Method: "GET",
+			Url:    "/api/admins",
+			Body:   strings.NewReader(`{"name":"test123"}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
+					return func(c echo.Context) error {
+						// it is not important whether the route handler return an error since
+						// we just need to ensure that the eagerRequestInfoCache was registered
+						next(c)
 
-	// supported eager cache request methods
-	supportedMethods := []string{"POST", "PUT", "PATCH", "DELETE"}
-	for _, m := range supportedMethods {
-		scenarios = append(
-			scenarios,
-			tests.ApiScenario{
-				Name:   fmt.Sprintf("[%s] valid cached json body request", m),
-				Method: http.MethodPost,
-				Url:    "/custom",
-				Body:   strings.NewReader(`{"name":"test123"}`),
-				BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
-					e.AddRoute(echo.Route{
-						Method: http.MethodPost,
-						Path:   "/custom",
-						Handler: func(c echo.Context) error {
-							data := &struct {
-								Name string `json:"name"`
-							}{}
+						// ensure that the body was read at least once
+						data := &struct {
+							Name string `json:"name"`
+						}{}
+						c.Bind(data)
 
-							if err := c.Bind(data); err != nil {
-								return err
-							}
+						// since the unknown method is not eager cache support
+						// it should fail reading the json body twice
+						r := apis.RequestInfo(c)
+						if v := cast.ToString(r.Data["name"]); v != "" {
+							t.Fatalf("Expected empty request data body, got, %v", r.Data)
+						}
 
-							// try to read the body again
-							r := apis.RequestData(c)
-							if v := cast.ToString(r.Data["name"]); v != "test123" {
-								t.Fatalf("Expected request data with name %q, got, %q", "test123", v)
-							}
-
-							return c.String(200, data.Name)
-						},
-					})
-				},
-				ExpectedStatus:  200,
-				ExpectedContent: []string{"test123"},
+						return nil
+					}
+				})
 			},
-		)
+			ExpectedStatus: 200,
+		},
+		{
+			Name:   "api group route with supported eager cache request method",
+			Method: "POST",
+			Url:    "/api/admins",
+			Body:   strings.NewReader(`{"name":"test123"}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
+					return func(c echo.Context) error {
+						// it is not important whether the route handler return an error since
+						// we just need to ensure that the eagerRequestInfoCache was registered
+						next(c)
+
+						// ensure that the body was read at least once
+						data := &struct {
+							Name string `json:"name"`
+						}{}
+						c.Bind(data)
+
+						// try to read the body again
+						r := apis.RequestInfo(c)
+						if v := cast.ToString(r.Data["name"]); v != "test123" {
+							t.Fatalf("Expected request data with name %q, got, %q", "test123", v)
+						}
+
+						return nil
+					}
+				})
+			},
+			ExpectedStatus: 200,
+		},
+	}
+
+	for _, scenario := range scenarios {
+		scenario.Test(t)
+	}
+}
+
+func TestErrorHandler(t *testing.T) {
+	scenarios := []tests.ApiScenario{
+		{
+			Name:   "apis.ApiError",
+			Method: http.MethodGet,
+			Url:    "/test",
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.GET("/test", func(c echo.Context) error {
+					return apis.NewApiError(418, "test", nil)
+				})
+			},
+			ExpectedStatus:  418,
+			ExpectedContent: []string{`"message":"Test."`},
+		},
+		{
+			Name:   "wrapped apis.ApiError",
+			Method: http.MethodGet,
+			Url:    "/test",
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.GET("/test", func(c echo.Context) error {
+					return fmt.Errorf("example 123: %w", apis.NewApiError(418, "test", nil))
+				})
+			},
+			ExpectedStatus:     418,
+			ExpectedContent:    []string{`"message":"Test."`},
+			NotExpectedContent: []string{"example", "123"},
+		},
+		{
+			Name:   "echo.HTTPError",
+			Method: http.MethodGet,
+			Url:    "/test",
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.GET("/test", func(c echo.Context) error {
+					return echo.NewHTTPError(418, "test")
+				})
+			},
+			ExpectedStatus:  418,
+			ExpectedContent: []string{`"message":"Test."`},
+		},
+		{
+			Name:   "wrapped echo.HTTPError",
+			Method: http.MethodGet,
+			Url:    "/test",
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.GET("/test", func(c echo.Context) error {
+					return fmt.Errorf("example 123: %w", echo.NewHTTPError(418, "test"))
+				})
+			},
+			ExpectedStatus:     418,
+			ExpectedContent:    []string{`"message":"Test."`},
+			NotExpectedContent: []string{"example", "123"},
+		},
+		{
+			Name:   "wrapped sql.ErrNoRows",
+			Method: http.MethodGet,
+			Url:    "/test",
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.GET("/test", func(c echo.Context) error {
+					return fmt.Errorf("example 123: %w", sql.ErrNoRows)
+				})
+			},
+			ExpectedStatus:     404,
+			ExpectedContent:    []string{`"data":{}`},
+			NotExpectedContent: []string{"example", "123"},
+		},
+		{
+			Name:   "custom error",
+			Method: http.MethodGet,
+			Url:    "/test",
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				e.GET("/test", func(c echo.Context) error {
+					return fmt.Errorf("example 123")
+				})
+			},
+			ExpectedStatus:     400,
+			ExpectedContent:    []string{`"data":{}`},
+			NotExpectedContent: []string{"example", "123"},
+		},
 	}
 
 	for _, scenario := range scenarios {

apis/collection.go

@@ -1,7 +1,6 @@
 package apis
 
 import (
-	"log"
 	"net/http"
 
 	"github.com/labstack/echo/v5"
@@ -49,6 +48,10 @@ func (api *collectionApi) list(c echo.Context) error {
 	event.Result = result
 
 	return api.app.OnCollectionsListRequest().Trigger(event, func(e *core.CollectionsListEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		return e.HttpContext.JSON(http.StatusOK, e.Result)
 	})
 }
@@ -64,6 +67,10 @@ func (api *collectionApi) view(c echo.Context) error {
 	event.Collection = collection
 
 	return api.app.OnCollectionViewRequest().Trigger(event, func(e *core.CollectionViewEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		return e.HttpContext.JSON(http.StatusOK, e.Collection)
 	})
 }
@@ -83,7 +90,7 @@ func (api *collectionApi) create(c echo.Context) error {
 	event.Collection = collection
 
 	// create the collection
-	submitErr := form.Submit(func(next forms.InterceptorNextFunc[*models.Collection]) forms.InterceptorNextFunc[*models.Collection] {
+	return form.Submit(func(next forms.InterceptorNextFunc[*models.Collection]) forms.InterceptorNextFunc[*models.Collection] {
 		return func(m *models.Collection) error {
 			event.Collection = m
 
@@ -92,18 +99,16 @@ func (api *collectionApi) create(c echo.Context) error {
 					return NewBadRequestError("Failed to create the collection.", err)
 				}
 
-				return e.HttpContext.JSON(http.StatusOK, e.Collection)
+				return api.app.OnCollectionAfterCreateRequest().Trigger(event, func(e *core.CollectionCreateEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.JSON(http.StatusOK, e.Collection)
+				})
 			})
 		}
 	})
-
-	if submitErr == nil {
-		if err := api.app.OnCollectionAfterCreateRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return submitErr
 }
 
 func (api *collectionApi) update(c echo.Context) error {
@@ -124,7 +129,7 @@ func (api *collectionApi) update(c echo.Context) error {
 	event.Collection = collection
 
 	// update the collection
-	submitErr := form.Submit(func(next forms.InterceptorNextFunc[*models.Collection]) forms.InterceptorNextFunc[*models.Collection] {
+	return form.Submit(func(next forms.InterceptorNextFunc[*models.Collection]) forms.InterceptorNextFunc[*models.Collection] {
 		return func(m *models.Collection) error {
 			event.Collection = m
 
@@ -133,18 +138,16 @@ func (api *collectionApi) update(c echo.Context) error {
 					return NewBadRequestError("Failed to update the collection.", err)
 				}
 
-				return e.HttpContext.JSON(http.StatusOK, e.Collection)
+				return api.app.OnCollectionAfterUpdateRequest().Trigger(event, func(e *core.CollectionUpdateEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.JSON(http.StatusOK, e.Collection)
+				})
 			})
 		}
 	})
-
-	if submitErr == nil {
-		if err := api.app.OnCollectionAfterUpdateRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return submitErr
 }
 
 func (api *collectionApi) delete(c echo.Context) error {
@@ -157,21 +160,19 @@ func (api *collectionApi) delete(c echo.Context) error {
 	event.HttpContext = c
 	event.Collection = collection
 
-	handlerErr := api.app.OnCollectionBeforeDeleteRequest().Trigger(event, func(e *core.CollectionDeleteEvent) error {
+	return api.app.OnCollectionBeforeDeleteRequest().Trigger(event, func(e *core.CollectionDeleteEvent) error {
 		if err := api.app.Dao().DeleteCollection(e.Collection); err != nil {
 			return NewBadRequestError("Failed to delete collection due to existing dependency.", err)
 		}
 
-		return e.HttpContext.NoContent(http.StatusNoContent)
+		return api.app.OnCollectionAfterDeleteRequest().Trigger(event, func(e *core.CollectionDeleteEvent) error {
+			if e.HttpContext.Response().Committed {
+				return nil
+			}
+
+			return e.HttpContext.NoContent(http.StatusNoContent)
+		})
 	})
-
-	if handlerErr == nil {
-		if err := api.app.OnCollectionAfterDeleteRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return handlerErr
 }
 
 func (api *collectionApi) bulkImport(c echo.Context) error {
@@ -187,7 +188,7 @@ func (api *collectionApi) bulkImport(c echo.Context) error {
 	event.Collections = form.Collections
 
 	// import collections
-	submitErr := form.Submit(func(next forms.InterceptorNextFunc[[]*models.Collection]) forms.InterceptorNextFunc[[]*models.Collection] {
+	return form.Submit(func(next forms.InterceptorNextFunc[[]*models.Collection]) forms.InterceptorNextFunc[[]*models.Collection] {
 		return func(imports []*models.Collection) error {
 			event.Collections = imports
 
@@ -196,16 +197,14 @@ func (api *collectionApi) bulkImport(c echo.Context) error {
 					return NewBadRequestError("Failed to import the submitted collections.", err)
 				}
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnCollectionsAfterImportRequest().Trigger(event, func(e *core.CollectionsImportEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
-
-	if submitErr == nil {
-		if err := api.app.OnCollectionsAfterImportRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return submitErr
 }

apis/collection_test.go

@@ -1,6 +1,7 @@
 package apis_test
 
 import (
+	"errors"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -9,8 +10,8 @@ import (
 	"time"
 
 	"github.com/labstack/echo/v5"
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/models"
-	"github.com/pocketbase/pocketbase/models/schema"
 	"github.com/pocketbase/pocketbase/tests"
 	"github.com/pocketbase/pocketbase/tools/list"
 )
@@ -45,7 +46,7 @@ func TestCollectionsList(t *testing.T) {
 			ExpectedContent: []string{
 				`"page":1`,
 				`"perPage":30`,
-				`"totalItems":10`,
+				`"totalItems":11`,
 				`"items":[{`,
 				`"id":"_pb_users_auth_"`,
 				`"id":"v851q4r790rhknl"`,
@@ -55,6 +56,7 @@ func TestCollectionsList(t *testing.T) {
 				`"id":"wzlqyes4orhoygb"`,
 				`"id":"4d1blo5cuycfaca"`,
 				`"id":"9n89pl5vkct6330"`,
+				`"id":"ib3m2700k5hlsjz"`,
 				`"type":"auth"`,
 				`"type":"base"`,
 			},
@@ -73,9 +75,9 @@ func TestCollectionsList(t *testing.T) {
 			ExpectedContent: []string{
 				`"page":2`,
 				`"perPage":2`,
-				`"totalItems":10`,
+				`"totalItems":11`,
 				`"items":[{`,
-				`"id":"kpv709sk2lqbqk8"`,
+				`"id":"v9gwnfh02gjq1q0"`,
 				`"id":"9n89pl5vkct6330"`,
 			},
 			ExpectedEvents: map[string]int{
@@ -243,7 +245,7 @@ func TestCollectionDelete(t *testing.T) {
 				"OnCollectionBeforeDeleteRequest": 1,
 				"OnCollectionAfterDeleteRequest":  1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				ensureDeletedFiles(app, "9n89pl5vkct6330")
 			},
 		},
@@ -262,7 +264,7 @@ func TestCollectionDelete(t *testing.T) {
 				"OnCollectionBeforeDeleteRequest": 1,
 				"OnCollectionAfterDeleteRequest":  1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				ensureDeletedFiles(app, "9n89pl5vkct6330")
 			},
 		},
@@ -299,7 +301,6 @@ func TestCollectionDelete(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
 			},
-			Delay:          100 * time.Millisecond,
 			ExpectedStatus: 204,
 			ExpectedEvents: map[string]int{
 				"OnModelBeforeDelete":             1,
@@ -308,6 +309,27 @@ func TestCollectionDelete(t *testing.T) {
 				"OnCollectionAfterDeleteRequest":  1,
 			},
 		},
+		{
+			Name:   "OnCollectionAfterDeleteRequest error response",
+			Method: http.MethodDelete,
+			Url:    "/api/collections/view2",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnCollectionAfterDeleteRequest().Add(func(e *core.CollectionDeleteEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelBeforeDelete":             1,
+				"OnModelAfterDelete":              1,
+				"OnCollectionBeforeDeleteRequest": 1,
+				"OnCollectionAfterDeleteRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -378,7 +400,7 @@ func TestCollectionCreate(t *testing.T) {
 				`"name":"new"`,
 				`"type":"base"`,
 				`"system":false`,
-				`"schema":[{"system":false,"id":"12345789","name":"test","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`,
+				`"schema":[{"system":false,"id":"12345789","name":"test","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`,
 				`"options":{}`,
 			},
 			ExpectedEvents: map[string]int{
@@ -402,7 +424,7 @@ func TestCollectionCreate(t *testing.T) {
 				`"name":"new"`,
 				`"type":"auth"`,
 				`"system":false`,
-				`"schema":[{"system":false,"id":"12345789","name":"test","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`,
+				`"schema":[{"system":false,"id":"12345789","name":"test","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`,
 				`"options":{"allowEmailAuth":false,"allowOAuth2Auth":false,"allowUsernameAuth":false,"exceptEmailDomains":null,"manageRule":null,"minPasswordLength":0,"onlyEmailDomains":null,"requireEmail":false}`,
 			},
 			ExpectedEvents: map[string]int{
@@ -536,6 +558,28 @@ func TestCollectionCreate(t *testing.T) {
 				`"options":{"minPasswordLength":{"code":"validation_required"`,
 			},
 		},
+		{
+			Name:   "OnCollectionAfterCreateRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/collections",
+			Body:   strings.NewReader(`{"name":"new","type":"base","schema":[{"type":"text","id":"12345789","name":"test"}]}`),
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnCollectionAfterCreateRequest().Add(func(e *core.CollectionCreateEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelBeforeCreate":             1,
+				"OnModelAfterCreate":              1,
+				"OnCollectionBeforeCreateRequest": 1,
+				"OnCollectionAfterCreateRequest":  1,
+			},
+		},
 
 		// view
 		// -----------------------------------------------------------
@@ -649,7 +693,7 @@ func TestCollectionCreate(t *testing.T) {
 				"OnCollectionBeforeCreateRequest": 1,
 				"OnCollectionAfterCreateRequest":  1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				indexes, err := app.Dao().TableIndexes("new")
 				if err != nil {
 					t.Fatal(err)
@@ -720,6 +764,28 @@ func TestCollectionUpdate(t *testing.T) {
 				"OnModelBeforeUpdate":             1,
 			},
 		},
+		{
+			Name:   "OnCollectionAfterUpdateRequest error response",
+			Method: http.MethodPatch,
+			Url:    "/api/collections/demo1",
+			Body:   strings.NewReader(`{}`),
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnCollectionAfterUpdateRequest().Add(func(e *core.CollectionUpdateEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnCollectionAfterUpdateRequest":  1,
+				"OnCollectionBeforeUpdateRequest": 1,
+				"OnModelAfterUpdate":              1,
+				"OnModelBeforeUpdate":             1,
+			},
+		},
 		{
 			Name:   "authorized as admin + invalid data (eg. existing name)",
 			Method: http.MethodPatch,
@@ -757,7 +823,7 @@ func TestCollectionUpdate(t *testing.T) {
 				"OnCollectionBeforeUpdateRequest": 1,
 				"OnCollectionAfterUpdateRequest":  1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				// check if the record table was renamed
 				if !app.Dao().HasTable("new") {
 					t.Fatal("Couldn't find record table 'new'.")
@@ -893,88 +959,6 @@ func TestCollectionUpdate(t *testing.T) {
 			},
 		},
 
-		// rel field change displayFields propagation
-		// -----------------------------------------------------------
-		{
-			Name:   "renaming a display field should also update the referenced displayFields value",
-			Method: http.MethodPatch,
-			Url:    "/api/collections/demo3",
-			Body: strings.NewReader(`{
-				"schema":[
-					{
-						"id": "w5z2x0nq",
-						"type": "text",
-						"name": "title_change"
-					}
-				]
-			}`),
-			RequestHeaders: map[string]string{
-				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
-			},
-			ExpectedStatus: 200,
-			ExpectedContent: []string{
-				`"name":"title_change"`,
-			},
-			ExpectedEvents: map[string]int{
-				"OnModelBeforeUpdate":             2,
-				"OnModelAfterUpdate":              2,
-				"OnCollectionBeforeUpdateRequest": 1,
-				"OnCollectionAfterUpdateRequest":  1,
-			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
-				collection, err := app.Dao().FindCollectionByNameOrId("demo4")
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				relField := collection.Schema.GetFieldByName("rel_many_no_cascade_required")
-				options := relField.Options.(*schema.RelationOptions)
-				expectedDisplayFields := []string{"title_change", "id"}
-				if len(list.SubtractSlice(options.DisplayFields, expectedDisplayFields)) != 0 {
-					t.Fatalf("Expected displayFields %v, got %v", expectedDisplayFields, options.DisplayFields)
-				}
-			},
-		},
-		{
-			Name:   "deleting a display field should also update the referenced displayFields value",
-			Method: http.MethodPatch,
-			Url:    "/api/collections/demo3",
-			Body: strings.NewReader(`{
-				"schema":[
-					{
-						"type": "text",
-						"name": "new_field"
-					}
-				]
-			}`),
-			RequestHeaders: map[string]string{
-				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
-			},
-			ExpectedStatus: 200,
-			ExpectedContent: []string{
-				`"name":"new_field"`,
-			},
-			ExpectedEvents: map[string]int{
-				"OnModelBeforeUpdate":             2,
-				"OnModelAfterUpdate":              2,
-				"OnCollectionBeforeUpdateRequest": 1,
-				"OnCollectionAfterUpdateRequest":  1,
-			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
-				collection, err := app.Dao().FindCollectionByNameOrId("demo4")
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				relField := collection.Schema.GetFieldByName("rel_many_no_cascade_required")
-				options := relField.Options.(*schema.RelationOptions)
-				expectedDisplayFields := []string{"id"}
-				if len(list.SubtractSlice(options.DisplayFields, expectedDisplayFields)) != 0 {
-					t.Fatalf("Expected displayFields %v, got %v", expectedDisplayFields, options.DisplayFields)
-				}
-			},
-		},
-
 		// view
 		// -----------------------------------------------------------
 		{
@@ -1076,7 +1060,7 @@ func TestCollectionUpdate(t *testing.T) {
 				"OnCollectionBeforeUpdateRequest": 1,
 				"OnCollectionAfterUpdateRequest":  1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				indexes, err := app.Dao().TableIndexes("new")
 				if err != nil {
 					t.Fatal(err)
@@ -1098,7 +1082,7 @@ func TestCollectionUpdate(t *testing.T) {
 }
 
 func TestCollectionsImport(t *testing.T) {
-	totalCollections := 10
+	totalCollections := 11
 
 	scenarios := []tests.ApiScenario{
 		{
@@ -1131,7 +1115,7 @@ func TestCollectionsImport(t *testing.T) {
 				`"data":{`,
 				`"collections":{"code":"validation_required"`,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				collections := []*models.Collection{}
 				if err := app.Dao().CollectionQuery().All(&collections); err != nil {
 					t.Fatal(err)
@@ -1159,7 +1143,7 @@ func TestCollectionsImport(t *testing.T) {
 				"OnCollectionsBeforeImportRequest": 1,
 				"OnModelBeforeDelete":              4,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				collections := []*models.Collection{}
 				if err := app.Dao().CollectionQuery().All(&collections); err != nil {
 					t.Fatal(err)
@@ -1201,7 +1185,7 @@ func TestCollectionsImport(t *testing.T) {
 				"OnCollectionsBeforeImportRequest": 1,
 				"OnModelBeforeCreate":              2,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				collections := []*models.Collection{}
 				if err := app.Dao().CollectionQuery().All(&collections); err != nil {
 					t.Fatal(err)
@@ -1257,7 +1241,7 @@ func TestCollectionsImport(t *testing.T) {
 				"OnModelBeforeCreate":              3,
 				"OnModelAfterCreate":               3,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				collections := []*models.Collection{}
 				if err := app.Dao().CollectionQuery().All(&collections); err != nil {
 					t.Fatal(err)
@@ -1355,14 +1339,14 @@ func TestCollectionsImport(t *testing.T) {
 			ExpectedEvents: map[string]int{
 				"OnCollectionsAfterImportRequest":  1,
 				"OnCollectionsBeforeImportRequest": 1,
-				"OnModelBeforeDelete":              8,
-				"OnModelAfterDelete":               8,
+				"OnModelBeforeDelete":              9,
+				"OnModelAfterDelete":               9,
 				"OnModelBeforeUpdate":              2,
 				"OnModelAfterUpdate":               2,
 				"OnModelBeforeCreate":              1,
 				"OnModelAfterCreate":               1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				collections := []*models.Collection{}
 				if err := app.Dao().CollectionQuery().All(&collections); err != nil {
 					t.Fatal(err)
@@ -1373,6 +1357,58 @@ func TestCollectionsImport(t *testing.T) {
 				}
 			},
 		},
+		{
+			Name:   "authorized as admin + successful collections save",
+			Method: http.MethodPut,
+			Url:    "/api/collections/import",
+			Body: strings.NewReader(`{
+				"collections":[
+					{
+						"name": "import1",
+						"schema": [
+							{
+							  "id": "koih1lqx",
+							  "name": "test",
+							  "type": "text"
+							}
+						]
+					},
+					{
+						"name": "import2",
+						"schema": [
+							{
+							  "id": "koih1lqx",
+							  "name": "test",
+							  "type": "text"
+							}
+						],
+						"indexes": [
+							"create index idx_test on import2 (test)"
+						]
+					},
+					{
+						"name": "auth_without_schema",
+						"type": "auth"
+					}
+				]
+			}`),
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnCollectionsAfterImportRequest().Add(func(e *core.CollectionsImportEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnCollectionsBeforeImportRequest": 1,
+				"OnCollectionsAfterImportRequest":  1,
+				"OnModelBeforeCreate":              3,
+				"OnModelAfterCreate":               3,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {

apis/file.go

@@ -3,19 +3,15 @@ package apis
 import (
 	"errors"
 	"fmt"
-	"log"
 	"net/http"
 	"strings"
 
 	"github.com/labstack/echo/v5"
-	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/models/schema"
-	"github.com/pocketbase/pocketbase/resolvers"
 	"github.com/pocketbase/pocketbase/tokens"
 	"github.com/pocketbase/pocketbase/tools/list"
-	"github.com/pocketbase/pocketbase/tools/search"
 	"github.com/pocketbase/pocketbase/tools/security"
 	"github.com/spf13/cast"
 )
@@ -49,23 +45,21 @@ func (api *fileApi) fileToken(c echo.Context) error {
 		event.Token, _ = tokens.NewRecordFileToken(api.app, record)
 	}
 
-	handlerErr := api.app.OnFileBeforeTokenRequest().Trigger(event, func(e *core.FileTokenEvent) error {
+	return api.app.OnFileBeforeTokenRequest().Trigger(event, func(e *core.FileTokenEvent) error {
 		if e.Model == nil || e.Token == "" {
 			return NewBadRequestError("Failed to generate file token.", nil)
 		}
 
-		return e.HttpContext.JSON(http.StatusOK, map[string]string{
-			"token": e.Token,
+		return api.app.OnFileAfterTokenRequest().Trigger(event, func(e *core.FileTokenEvent) error {
+			if e.HttpContext.Response().Committed {
+				return nil
+			}
+
+			return e.HttpContext.JSON(http.StatusOK, map[string]string{
+				"token": e.Token,
+			})
 		})
 	})
-
-	if handlerErr == nil {
-		if err := api.app.OnFileAfterTokenRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return handlerErr
 }
 
 func (api *fileApi) download(c echo.Context) error {
@@ -102,7 +96,19 @@ func (api *fileApi) download(c echo.Context) error {
 
 		adminOrAuthRecord, _ := api.findAdminOrAuthRecordByFileToken(token)
 
-		if !api.canAccessRecord(adminOrAuthRecord, record, record.Collection().ViewRule) {
+		// create a copy of the cached request data and adjust it for the current auth model
+		requestInfo := *RequestInfo(c)
+		requestInfo.Admin = nil
+		requestInfo.AuthRecord = nil
+		if adminOrAuthRecord != nil {
+			if admin, _ := adminOrAuthRecord.(*models.Admin); admin != nil {
+				requestInfo.Admin = admin
+			} else if record, _ := adminOrAuthRecord.(*models.Record); record != nil {
+				requestInfo.AuthRecord = record
+			}
+		}
+
+		if ok, _ := api.app.Dao().CanAccessRecord(record, &requestInfo, record.Collection().ViewRule); !ok {
 			return NewForbiddenError("Insufficient permissions to access the file resource.", nil)
 		}
 	}
@@ -166,9 +172,11 @@ func (api *fileApi) download(c echo.Context) error {
 	c.Response().Header().Del("X-Frame-Options")
 
 	return api.app.OnFileDownloadRequest().Trigger(event, func(e *core.FileDownloadEvent) error {
-		res := e.HttpContext.Response()
-		req := e.HttpContext.Request()
-		if err := fs.Serve(res, req, e.ServedPath, e.ServedName); err != nil {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
+		if err := fs.Serve(e.HttpContext.Response(), e.HttpContext.Request(), e.ServedPath, e.ServedName); err != nil {
 			return NewNotFoundError("", err)
 		}
 
@@ -206,46 +214,3 @@ func (api *fileApi) findAdminOrAuthRecordByFileToken(fileToken string) (models.M
 
 	return nil, errors.New("missing or invalid file token")
 }
-
-// @todo move to a helper and maybe combine with the realtime checks when refactoring the realtime service
-func (api *fileApi) canAccessRecord(adminOrAuthRecord models.Model, record *models.Record, accessRule *string) bool {
-	admin, _ := adminOrAuthRecord.(*models.Admin)
-	if admin != nil {
-		// admins can access everything
-		return true
-	}
-
-	if accessRule == nil {
-		// only admins can access this record
-		return false
-	}
-
-	ruleFunc := func(q *dbx.SelectQuery) error {
-		if *accessRule == "" {
-			return nil // empty public rule
-		}
-
-		// mock request data
-		requestData := &models.RequestData{
-			Method: "GET",
-		}
-		requestData.AuthRecord, _ = adminOrAuthRecord.(*models.Record)
-
-		resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), record.Collection(), requestData, true)
-		expr, err := search.FilterData(*accessRule).BuildExpr(resolver)
-		if err != nil {
-			return err
-		}
-		resolver.UpdateQuery(q)
-		q.AndWhere(expr)
-
-		return nil
-	}
-
-	foundRecord, err := api.app.Dao().FindRecordById(record.Collection().Id, record.Id, ruleFunc)
-	if err == nil && foundRecord != nil {
-		return true
-	}
-
-	return false
-}

apis/middlewares.go

@@ -129,14 +129,17 @@ func RequireAdminAuth() echo.MiddlewareFunc {
 func RequireAdminAuthOnlyIfAny(app core.App) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
+			admin, _ := c.Get(ContextAdminKey).(*models.Admin)
+			if admin != nil {
+				return next(c)
+			}
+
 			totalAdmins, err := app.Dao().TotalAdmins()
 			if err != nil {
 				return NewBadRequestError("Failed to fetch admins info.", err)
 			}
 
-			admin, _ := c.Get(ContextAdminKey).(*models.Admin)
-
-			if admin != nil || totalAdmins == 0 {
+			if totalAdmins == 0 {
 				return next(c)
 			}
 
@@ -284,8 +287,10 @@ func ActivityLogger(app core.App) echo.MiddlewareFunc {
 		return func(c echo.Context) error {
 			err := next(c)
 
+			logsMaxDays := app.Settings().Logs.MaxDays
+
 			// no logs retention
-			if app.Settings().Logs.MaxDays == 0 {
+			if logsMaxDays == 0 {
 				return err
 			}
 
@@ -345,8 +350,8 @@ func ActivityLogger(app core.App) echo.MiddlewareFunc {
 				lastLogsDeletedAt := cast.ToTime(app.Cache().Get("lastLogsDeletedAt"))
 				daysDiff := now.Sub(lastLogsDeletedAt).Hours() * 24
 
-				if daysDiff > float64(app.Settings().Logs.MaxDays) {
-					deleteErr := app.LogsDao().DeleteOldRequests(now.AddDate(0, 0, -1*app.Settings().Logs.MaxDays))
+				if daysDiff > float64(logsMaxDays) {
+					deleteErr := app.LogsDao().DeleteOldRequests(now.AddDate(0, 0, -1*logsMaxDays))
 					if deleteErr == nil {
 						app.Cache().Set("lastLogsDeletedAt", now)
 					} else if app.IsDebug() {
@@ -390,15 +395,15 @@ func realUserIp(r *http.Request, fallbackIp string) string {
 	return fallbackIp
 }
 
-// eagerRequestDataCache ensures that the request data is cached in the request
+// eagerRequestInfoCache ensures that the request data is cached in the request
 // context to allow reading for example the json request body data more than once.
-func eagerRequestDataCache(app core.App) echo.MiddlewareFunc {
+func eagerRequestInfoCache(app core.App) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			switch c.Request().Method {
 			// currently we are eagerly caching only the requests with body
 			case "POST", "PUT", "PATCH", "DELETE":
-				RequestData(c)
+				RequestInfo(c)
 			}
 
 			return next(c)

apis/realtime.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"log"
 	"net/http"
 	"strings"
@@ -57,9 +56,8 @@ func (api *realtimeApi) connect(c echo.Context) error {
 		api.app.SubscriptionsBroker().Unregister(client.Id())
 	}()
 
-	c.Response().Header().Set("Content-Type", "text/event-stream; charset=UTF-8")
+	c.Response().Header().Set("Content-Type", "text/event-stream")
 	c.Response().Header().Set("Cache-Control", "no-store")
-	c.Response().Header().Set("Connection", "keep-alive")
 	// https://github.com/pocketbase/pocketbase/discussions/480#discussioncomment-3657640
 	// https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_buffering
 	c.Response().Header().Set("X-Accel-Buffering", "no")
@@ -67,6 +65,7 @@ func (api *realtimeApi) connect(c echo.Context) error {
 	connectEvent := &core.RealtimeConnectEvent{
 		HttpContext: c,
 		Client:      client,
+		IdleTimeout: 5 * time.Minute,
 	}
 
 	if err := api.app.OnRealtimeConnectRequest().Trigger(connectEvent); err != nil {
@@ -83,16 +82,18 @@ func (api *realtimeApi) connect(c echo.Context) error {
 		Client:      client,
 		Message: &subscriptions.Message{
 			Name: "PB_CONNECT",
-			Data: `{"clientId":"` + client.Id() + `"}`,
+			Data: []byte(`{"clientId":"` + client.Id() + `"}`),
 		},
 	}
 	connectMsgErr := api.app.OnRealtimeBeforeMessageSend().Trigger(connectMsgEvent, func(e *core.RealtimeMessageEvent) error {
 		w := e.HttpContext.Response()
-		fmt.Fprint(w, "id:"+client.Id()+"\n")
-		fmt.Fprint(w, "event:"+e.Message.Name+"\n")
-		fmt.Fprint(w, "data:"+e.Message.Data+"\n\n")
+		w.Write([]byte("id:" + client.Id() + "\n"))
+		w.Write([]byte("event:" + e.Message.Name + "\n"))
+		w.Write([]byte("data:"))
+		w.Write(e.Message.Data)
+		w.Write([]byte("\n\n"))
 		w.Flush()
-		return nil
+		return api.app.OnRealtimeAfterMessageSend().Trigger(e)
 	})
 	if connectMsgErr != nil {
 		if api.app.IsDebug() {
@@ -100,13 +101,10 @@ func (api *realtimeApi) connect(c echo.Context) error {
 		}
 		return nil
 	}
-	if err := api.app.OnRealtimeAfterMessageSend().Trigger(connectMsgEvent); err != nil && api.app.IsDebug() {
-		log.Println("OnRealtimeAfterMessageSend PB_CONNECT error:", err)
-	}
 
 	// start an idle timer to keep track of inactive/forgotten connections
-	idleDuration := 5 * time.Minute
-	idleTimer := time.NewTimer(idleDuration)
+	idleTimeout := connectEvent.IdleTimeout
+	idleTimer := time.NewTimer(idleTimeout)
 	defer idleTimer.Stop()
 
 	for {
@@ -129,11 +127,13 @@ func (api *realtimeApi) connect(c echo.Context) error {
 			}
 			msgErr := api.app.OnRealtimeBeforeMessageSend().Trigger(msgEvent, func(e *core.RealtimeMessageEvent) error {
 				w := e.HttpContext.Response()
-				fmt.Fprint(w, "id:"+e.Client.Id()+"\n")
-				fmt.Fprint(w, "event:"+e.Message.Name+"\n")
-				fmt.Fprint(w, "data:"+e.Message.Data+"\n\n")
+				w.Write([]byte("id:" + e.Client.Id() + "\n"))
+				w.Write([]byte("event:" + e.Message.Name + "\n"))
+				w.Write([]byte("data:"))
+				w.Write(e.Message.Data)
+				w.Write([]byte("\n\n"))
 				w.Flush()
-				return nil
+				return api.app.OnRealtimeAfterMessageSend().Trigger(msgEvent)
 			})
 			if msgErr != nil {
 				if api.app.IsDebug() {
@@ -142,12 +142,8 @@ func (api *realtimeApi) connect(c echo.Context) error {
 				return nil
 			}
 
-			if err := api.app.OnRealtimeAfterMessageSend().Trigger(msgEvent); err != nil && api.app.IsDebug() {
-				log.Println("OnRealtimeAfterMessageSend error:", err)
-			}
-
 			idleTimer.Stop()
-			idleTimer.Reset(idleDuration)
+			idleTimer.Reset(idleTimeout)
 		case <-c.Request().Context().Done():
 			// connection is closed
 			if api.app.IsDebug() {
@@ -191,7 +187,7 @@ func (api *realtimeApi) setSubscriptions(c echo.Context) error {
 		Subscriptions: form.Subscriptions,
 	}
 
-	handlerErr := api.app.OnRealtimeBeforeSubscribeRequest().Trigger(event, func(e *core.RealtimeSubscribeEvent) error {
+	return api.app.OnRealtimeBeforeSubscribeRequest().Trigger(event, func(e *core.RealtimeSubscribeEvent) error {
 		// update auth state
 		e.Client.Set(ContextAdminKey, e.HttpContext.Get(ContextAdminKey))
 		e.Client.Set(ContextAuthRecordKey, e.HttpContext.Get(ContextAuthRecordKey))
@@ -202,14 +198,14 @@ func (api *realtimeApi) setSubscriptions(c echo.Context) error {
 		// subscribe to the new subscriptions
 		e.Client.Subscribe(e.Subscriptions...)
 
-		return e.HttpContext.NoContent(http.StatusNoContent)
+		return api.app.OnRealtimeAfterSubscribeRequest().Trigger(event, func(e *core.RealtimeSubscribeEvent) error {
+			if e.HttpContext.Response().Committed {
+				return nil
+			}
+
+			return e.HttpContext.NoContent(http.StatusNoContent)
+		})
 	})
-
-	if handlerErr == nil {
-		api.app.OnRealtimeAfterSubscribeRequest().Trigger(event)
-	}
-
-	return handlerErr
 }
 
 // updateClientsAuthModel updates the existing clients auth model with the new one (matched by ID).
@@ -269,7 +265,7 @@ func (api *realtimeApi) bindEvents() {
 
 	api.app.OnModelAfterCreate().PreAdd(func(e *core.ModelEvent) error {
 		if record := api.resolveRecord(e.Model); record != nil {
-			if err := api.broadcastRecord("create", record); err != nil && api.app.IsDebug() {
+			if err := api.broadcastRecord("create", record, false); err != nil && api.app.IsDebug() {
 				log.Println(err)
 			}
 		}
@@ -278,7 +274,7 @@ func (api *realtimeApi) bindEvents() {
 
 	api.app.OnModelAfterUpdate().PreAdd(func(e *core.ModelEvent) error {
 		if record := api.resolveRecord(e.Model); record != nil {
-			if err := api.broadcastRecord("update", record); err != nil && api.app.IsDebug() {
+			if err := api.broadcastRecord("update", record, false); err != nil && api.app.IsDebug() {
 				log.Println(err)
 			}
 		}
@@ -287,7 +283,16 @@ func (api *realtimeApi) bindEvents() {
 
 	api.app.OnModelBeforeDelete().Add(func(e *core.ModelEvent) error {
 		if record := api.resolveRecord(e.Model); record != nil {
-			if err := api.broadcastRecord("delete", record); err != nil && api.app.IsDebug() {
+			if err := api.broadcastRecord("delete", record, true); err != nil && api.app.IsDebug() {
+				log.Println(err)
+			}
+		}
+		return nil
+	})
+
+	api.app.OnModelAfterDelete().Add(func(e *core.ModelEvent) error {
+		if record := api.resolveRecord(e.Model); record != nil {
+			if err := api.broadcastDryCachedRecord("delete", record); err != nil && api.app.IsDebug() {
 				log.Println(err)
 			}
 		}
@@ -340,12 +345,12 @@ func (api *realtimeApi) canAccessRecord(client subscriptions.Client, record *mod
 		}
 
 		// mock request data
-		requestData := &models.RequestData{
+		requestInfo := &models.RequestInfo{
 			Method: "GET",
 		}
-		requestData.AuthRecord, _ = client.Get(ContextAuthRecordKey).(*models.Record)
+		requestInfo.AuthRecord, _ = client.Get(ContextAuthRecordKey).(*models.Record)
 
-		resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), record.Collection(), requestData, true)
+		resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), record.Collection(), requestInfo, true)
 		expr, err := search.FilterData(*accessRule).BuildExpr(resolver)
 		if err != nil {
 			return err
@@ -365,11 +370,11 @@ func (api *realtimeApi) canAccessRecord(client subscriptions.Client, record *mod
 }
 
 type recordData struct {
-	Action string         `json:"action"`
 	Record *models.Record `json:"record"`
+	Action string         `json:"action"`
 }
 
-func (api *realtimeApi) broadcastRecord(action string, record *models.Record) error {
+func (api *realtimeApi) broadcastRecord(action string, record *models.Record, dryCache bool) error {
 	collection := record.Collection()
 	if collection == nil {
 		return errors.New("Record collection not set.")
@@ -401,14 +406,9 @@ func (api *realtimeApi) broadcastRecord(action string, record *models.Record) er
 
 	dataBytes, err := json.Marshal(data)
 	if err != nil {
-		if api.app.IsDebug() {
-			log.Println(err)
-		}
 		return err
 	}
 
-	encodedData := string(dataBytes)
-
 	for _, client := range clients {
 		client := client
 
@@ -423,7 +423,7 @@ func (api *realtimeApi) broadcastRecord(action string, record *models.Record) er
 
 			msg := subscriptions.Message{
 				Name: subscription,
-				Data: encodedData,
+				Data: dataBytes,
 			}
 
 			// ignore the auth record email visibility checks for
@@ -434,23 +434,48 @@ func (api *realtimeApi) broadcastRecord(action string, record *models.Record) er
 					api.canAccessRecord(client, data.Record, collection.AuthOptions().ManageRule) {
 					data.Record.IgnoreEmailVisibility(true) // ignore
 					if newData, err := json.Marshal(data); err == nil {
-						msg.Data = string(newData)
+						msg.Data = newData
 					}
 					data.Record.IgnoreEmailVisibility(false) // restore
 				}
 			}
 
-			routine.FireAndForget(func() {
-				if !client.IsDiscarded() {
-					client.Channel() <- msg
-				}
-			})
+			if dryCache {
+				client.Set(action+"/"+data.Record.Id, msg)
+			} else {
+				routine.FireAndForget(func() {
+					client.Send(msg)
+				})
+			}
 		}
 	}
 
 	return nil
 }
 
+// broadcastDryCachedRecord broadcasts record if it is cached in the client context.
+func (api *realtimeApi) broadcastDryCachedRecord(action string, record *models.Record) error {
+	clients := api.app.SubscriptionsBroker().Clients()
+
+	for _, client := range clients {
+		key := action + "/" + record.Id
+
+		msg, ok := client.Get(key).(subscriptions.Message)
+		if !ok {
+			continue
+		}
+
+		client.Unset(key)
+
+		client := client
+
+		routine.FireAndForget(func() {
+			client.Send(msg)
+		})
+	}
+	return nil
+}
+
 type getter interface {
 	Get(string) any
 }

apis/realtime_test.go

@@ -34,7 +34,7 @@ func TestRealtimeConnect(t *testing.T) {
 				"OnRealtimeAfterMessageSend":  1,
 				"OnRealtimeDisconnectRequest": 1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				if len(app.SubscriptionsBroker().Clients()) != 0 {
 					t.Errorf("Expected the subscribers to be removed after connection close, found %d", len(app.SubscriptionsBroker().Clients()))
 				}
@@ -58,7 +58,7 @@ func TestRealtimeConnect(t *testing.T) {
 					return nil
 				})
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				if len(app.SubscriptionsBroker().Clients()) != 0 {
 					t.Errorf("Expected the subscribers to be removed after connection close, found %d", len(app.SubscriptionsBroker().Clients()))
 				}
@@ -72,7 +72,6 @@ func TestRealtimeConnect(t *testing.T) {
 			ExpectedEvents: map[string]int{
 				"OnRealtimeConnectRequest":    1,
 				"OnRealtimeBeforeMessageSend": 1,
-				"OnRealtimeAfterMessageSend":  1,
 				"OnRealtimeDisconnectRequest": 1,
 			},
 			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
@@ -80,7 +79,7 @@ func TestRealtimeConnect(t *testing.T) {
 					return hook.StopPropagation
 				})
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				if len(app.SubscriptionsBroker().Clients()) != 0 {
 					t.Errorf("Expected the subscribers to be removed after connection close, found %d", len(app.SubscriptionsBroker().Clients()))
 				}
@@ -125,7 +124,7 @@ func TestRealtimeSubscribe(t *testing.T) {
 				client.Subscribe("test0")
 				app.SubscriptionsBroker().Register(client)
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				if len(client.Subscriptions()) != 0 {
 					t.Errorf("Expected no subscriptions, got %v", client.Subscriptions())
 				}
@@ -146,7 +145,7 @@ func TestRealtimeSubscribe(t *testing.T) {
 				client.Subscribe("test0")
 				app.SubscriptionsBroker().Register(client)
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				expectedSubs := []string{"test1", "test2"}
 				if len(expectedSubs) != len(client.Subscriptions()) {
 					t.Errorf("Expected subscriptions %v, got %v", expectedSubs, client.Subscriptions())
@@ -176,7 +175,7 @@ func TestRealtimeSubscribe(t *testing.T) {
 			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
 				app.SubscriptionsBroker().Register(client)
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				admin, _ := client.Get(apis.ContextAdminKey).(*models.Admin)
 				if admin == nil {
 					t.Errorf("Expected admin auth model, got nil")
@@ -200,7 +199,7 @@ func TestRealtimeSubscribe(t *testing.T) {
 			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
 				app.SubscriptionsBroker().Register(client)
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				authRecord, _ := client.Get(apis.ContextAuthRecordKey).(*models.Record)
 				if authRecord == nil {
 					t.Errorf("Expected auth record model, got nil")
@@ -225,7 +224,7 @@ func TestRealtimeSubscribe(t *testing.T) {
 
 				app.SubscriptionsBroker().Register(client)
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				authRecord, _ := client.Get(apis.ContextAuthRecordKey).(*models.Record)
 				if authRecord == nil {
 					t.Errorf("Expected auth record model, got nil")

apis/record_auth.go

@@ -65,17 +65,11 @@ func (api *recordAuthApi) authRefresh(c echo.Context) error {
 	event.Collection = record.Collection()
 	event.Record = record
 
-	handlerErr := api.app.OnRecordBeforeAuthRefreshRequest().Trigger(event, func(e *core.RecordAuthRefreshEvent) error {
-		return RecordAuthResponse(api.app, e.HttpContext, e.Record, nil)
+	return api.app.OnRecordBeforeAuthRefreshRequest().Trigger(event, func(e *core.RecordAuthRefreshEvent) error {
+		return api.app.OnRecordAfterAuthRefreshRequest().Trigger(event, func(e *core.RecordAuthRefreshEvent) error {
+			return RecordAuthResponse(api.app, e.HttpContext, e.Record, nil)
+		})
 	})
-
-	if handlerErr == nil {
-		if err := api.app.OnRecordAfterAuthRefreshRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return handlerErr
 }
 
 type providerInfo struct {
@@ -139,9 +133,14 @@ func (api *recordAuthApi) authMethods(c echo.Context) error {
 			oauth2.SetAuthURLParam("code_challenge_method", codeChallengeMethod),
 		}
 
-		if name == auth.NameApple {
+		// custom providers url options
+		switch name {
+		case auth.NameApple:
 			// see https://developer.apple.com/documentation/sign_in_with_apple/sign_in_with_apple_js/incorporating_sign_in_with_apple_into_other_platforms#3332113
 			urlOpts = append(urlOpts, oauth2.SetAuthURLParam("response_mode", "query"))
+		case auth.NameVK:
+			// vk currently doesn't support PKCE for server-side authorization
+			urlOpts = []oauth2.AuthCodeOption{}
 		}
 
 		result.AuthProviders = append(result.AuthProviders, providerInfo{
@@ -192,8 +191,8 @@ func (api *recordAuthApi) authWithOAuth2(c echo.Context) error {
 		return createForm.DrySubmit(func(txDao *daos.Dao) error {
 			event.IsNewRecord = true
 			// clone the current request data and assign the form create data as its body data
-			requestData := *RequestData(c)
-			requestData.Data = form.CreateData
+			requestInfo := *RequestInfo(c)
+			requestInfo.Data = form.CreateData
 
 			createRuleFunc := func(q *dbx.SelectQuery) error {
 				admin, _ := c.Get(ContextAdminKey).(*models.Admin)
@@ -206,7 +205,7 @@ func (api *recordAuthApi) authWithOAuth2(c echo.Context) error {
 				}
 
 				if *collection.CreateRule != "" {
-					resolver := resolvers.NewRecordFieldResolver(txDao, collection, &requestData, true)
+					resolver := resolvers.NewRecordFieldResolver(txDao, collection, &requestInfo, true)
 					expr, err := search.FilterData(*collection.CreateRule).BuildExpr(resolver)
 					if err != nil {
 						return err
@@ -251,17 +250,13 @@ func (api *recordAuthApi) authWithOAuth2(c echo.Context) error {
 					IsNew:    event.IsNewRecord,
 				}
 
-				return RecordAuthResponse(api.app, e.HttpContext, e.Record, meta)
+				return api.app.OnRecordAfterAuthWithOAuth2Request().Trigger(event, func(e *core.RecordAuthWithOAuth2Event) error {
+					return RecordAuthResponse(api.app, e.HttpContext, e.Record, meta)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterAuthWithOAuth2Request().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -291,17 +286,13 @@ func (api *recordAuthApi) authWithPassword(c echo.Context) error {
 					return NewBadRequestError("Failed to authenticate.", err)
 				}
 
-				return RecordAuthResponse(api.app, e.HttpContext, e.Record, nil)
+				return api.app.OnRecordAfterAuthWithPasswordRequest().Trigger(event, func(e *core.RecordAuthWithPasswordEvent) error {
+					return RecordAuthResponse(api.app, e.HttpContext, e.Record, nil)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterAuthWithPasswordRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -341,25 +332,24 @@ func (api *recordAuthApi) requestPasswordReset(c echo.Context) error {
 					}
 				})
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnRecordAfterRequestPasswordResetRequest().Trigger(event, func(e *core.RecordRequestPasswordResetEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterRequestPasswordResetRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	} else if api.app.IsDebug() {
-		log.Println(submitErr)
-	}
-
-	// don't return the response error to prevent emails enumeration
+	// eagerly write 204 response and skip submit errors
+	// as a measure against emails enumeration
 	if !c.Response().Committed {
 		c.NoContent(http.StatusNoContent)
 	}
 
-	return nil
+	return submitErr
 }
 
 func (api *recordAuthApi) confirmPasswordReset(c echo.Context) error {
@@ -386,17 +376,17 @@ func (api *recordAuthApi) confirmPasswordReset(c echo.Context) error {
 					return NewBadRequestError("Failed to set new password.", err)
 				}
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnRecordAfterConfirmPasswordResetRequest().Trigger(event, func(e *core.RecordConfirmPasswordResetEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterConfirmPasswordResetRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -431,25 +421,24 @@ func (api *recordAuthApi) requestVerification(c echo.Context) error {
 					}
 				})
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnRecordAfterRequestVerificationRequest().Trigger(event, func(e *core.RecordRequestVerificationEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterRequestVerificationRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	} else if api.app.IsDebug() {
-		log.Println(submitErr)
-	}
-
-	// don't return the response error to prevent emails enumeration
+	// eagerly write 204 response and skip submit errors
+	// as a measure against users enumeration
 	if !c.Response().Committed {
 		c.NoContent(http.StatusNoContent)
 	}
 
-	return nil
+	return submitErr
 }
 
 func (api *recordAuthApi) confirmVerification(c echo.Context) error {
@@ -476,17 +465,17 @@ func (api *recordAuthApi) confirmVerification(c echo.Context) error {
 					return NewBadRequestError("An error occurred while submitting the form.", err)
 				}
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnRecordAfterConfirmVerificationRequest().Trigger(event, func(e *core.RecordConfirmVerificationEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterConfirmVerificationRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -511,23 +500,23 @@ func (api *recordAuthApi) requestEmailChange(c echo.Context) error {
 	event.Collection = collection
 	event.Record = record
 
-	submitErr := form.Submit(func(next forms.InterceptorNextFunc[*models.Record]) forms.InterceptorNextFunc[*models.Record] {
+	return form.Submit(func(next forms.InterceptorNextFunc[*models.Record]) forms.InterceptorNextFunc[*models.Record] {
 		return func(record *models.Record) error {
 			return api.app.OnRecordBeforeRequestEmailChangeRequest().Trigger(event, func(e *core.RecordRequestEmailChangeEvent) error {
 				if err := next(e.Record); err != nil {
 					return NewBadRequestError("Failed to request email change.", err)
 				}
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnRecordAfterRequestEmailChangeRequest().Trigger(event, func(e *core.RecordRequestEmailChangeEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
-
-	if submitErr == nil {
-		api.app.OnRecordAfterRequestEmailChangeRequest().Trigger(event)
-	}
-
-	return submitErr
 }
 
 func (api *recordAuthApi) confirmEmailChange(c echo.Context) error {
@@ -554,17 +543,17 @@ func (api *recordAuthApi) confirmEmailChange(c echo.Context) error {
 					return NewBadRequestError("Failed to confirm email change.", err)
 				}
 
-				return e.HttpContext.NoContent(http.StatusNoContent)
+				return api.app.OnRecordAfterConfirmEmailChangeRequest().Trigger(event, func(e *core.RecordConfirmEmailChangeEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.NoContent(http.StatusNoContent)
+				})
 			})
 		}
 	})
 
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterConfirmEmailChangeRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
 	return submitErr
 }
 
@@ -628,19 +617,19 @@ func (api *recordAuthApi) unlinkExternalAuth(c echo.Context) error {
 	event.Record = record
 	event.ExternalAuth = externalAuth
 
-	handlerErr := api.app.OnRecordBeforeUnlinkExternalAuthRequest().Trigger(event, func(e *core.RecordUnlinkExternalAuthEvent) error {
+	return api.app.OnRecordBeforeUnlinkExternalAuthRequest().Trigger(event, func(e *core.RecordUnlinkExternalAuthEvent) error {
 		if err := api.app.Dao().DeleteExternalAuth(externalAuth); err != nil {
 			return NewBadRequestError("Cannot unlink the external auth provider.", err)
 		}
 
-		return e.HttpContext.NoContent(http.StatusNoContent)
+		return api.app.OnRecordAfterUnlinkExternalAuthRequest().Trigger(event, func(e *core.RecordUnlinkExternalAuthEvent) error {
+			if e.HttpContext.Response().Committed {
+				return nil
+			}
+
+			return e.HttpContext.NoContent(http.StatusNoContent)
+		})
 	})
-
-	if handlerErr == nil {
-		api.app.OnRecordAfterUnlinkExternalAuthRequest().Trigger(event)
-	}
-
-	return handlerErr
 }
 
 // -------------------------------------------------------------------
@@ -672,10 +661,10 @@ func (api *recordAuthApi) oauth2SubscriptionRedirect(c echo.Context) error {
 
 	msg := subscriptions.Message{
 		Name: oauth2SubscriptionTopic,
-		Data: string(encodedData),
+		Data: encodedData,
 	}
 
-	client.Channel() <- msg
+	client.Send(msg)
 
 	return c.Redirect(http.StatusTemporaryRedirect, "../_/#/auth/oauth2-redirect")
 }

apis/record_auth_test.go

@@ -2,12 +2,14 @@ package apis_test
 
 import (
 	"context"
+	"errors"
 	"net/http"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/labstack/echo/v5"
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/tests"
 	"github.com/pocketbase/pocketbase/tools/subscriptions"
@@ -280,6 +282,28 @@ func TestRecordAuthWithPassword(t *testing.T) {
 				"OnRecordAuthRequest":                   1,
 			},
 		},
+
+		// after hooks error checks
+		{
+			Name:   "OnRecordAfterAuthWithPasswordRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/collections/users/auth-with-password",
+			Body: strings.NewReader(`{
+				"identity":"test2_username",
+				"password":"1234567890"
+			}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterAuthWithPasswordRequest().Add(func(e *core.RecordAuthWithPasswordEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnRecordBeforeAuthWithPasswordRequest": 1,
+				"OnRecordAfterAuthWithPasswordRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -353,6 +377,25 @@ func TestRecordAuthRefresh(t *testing.T) {
 				"OnRecordAfterAuthRefreshRequest":  1,
 			},
 		},
+		{
+			Name:   "OnRecordAfterAuthRefreshRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/collections/users/auth-refresh?expand=rel,missing",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjRxMXhsY2xtZmxva3UzMyIsInR5cGUiOiJhdXRoUmVjb3JkIiwiY29sbGVjdGlvbklkIjoiX3BiX3VzZXJzX2F1dGhfIiwiZXhwIjoyMjA4OTg1MjYxfQ.UwD8JvkbQtXpymT09d7J6fdA0aP9g4FJ1GPh_ggEkzc",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterAuthRefreshRequest().Add(func(e *core.RecordAuthRefreshEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnRecordBeforeAuthRefreshRequest": 1,
+				"OnRecordAfterAuthRefreshRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -494,10 +537,8 @@ func TestRecordAuthConfirmPasswordReset(t *testing.T) {
 				"password":"12345678",
 				"passwordConfirm":"12345678"
 			}`),
-			ExpectedStatus: 400,
-			ExpectedContent: []string{
-				`"data":{}`,
-			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
 		},
 		{
 			Name:   "different auth collection",
@@ -530,6 +571,29 @@ func TestRecordAuthConfirmPasswordReset(t *testing.T) {
 				"OnRecordAfterConfirmPasswordResetRequest":  1,
 			},
 		},
+		{
+			Name:   "OnRecordAfterConfirmPasswordResetRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/collections/users/confirm-password-reset",
+			Body: strings.NewReader(`{
+				"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjRxMXhsY2xtZmxva3UzMyIsImVtYWlsIjoidGVzdEBleGFtcGxlLmNvbSIsImNvbGxlY3Rpb25JZCI6Il9wYl91c2Vyc19hdXRoXyIsInR5cGUiOiJhdXRoUmVjb3JkIiwiZXhwIjoyMjA4OTg1MjYxfQ.R_4FOSUHIuJQ5Crl3PpIPCXMsoHzuTaNlccpXg_3FOg",
+				"password":"12345678",
+				"passwordConfirm":"12345678"
+			}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterConfirmPasswordResetRequest().Add(func(e *core.RecordConfirmPasswordResetEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelAfterUpdate":                        1,
+				"OnModelBeforeUpdate":                       1,
+				"OnRecordBeforeConfirmPasswordResetRequest": 1,
+				"OnRecordAfterConfirmPasswordResetRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -671,10 +735,8 @@ func TestRecordAuthConfirmVerification(t *testing.T) {
 			Body: strings.NewReader(`{
 				"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjRxMXhsY2xtZmxva3UzMyIsImVtYWlsIjoidGVzdEBleGFtcGxlLmNvbSIsImNvbGxlY3Rpb25JZCI6Il9wYl91c2Vyc19hdXRoXyIsInR5cGUiOiJhdXRoUmVjb3JkIiwiZXhwIjoyMjA4OTg1MjYxfQ.R_4FOSUHIuJQ5Crl3PpIPCXMsoHzuTaNlccpXg_3FOg"
 			}`),
-			ExpectedStatus: 400,
-			ExpectedContent: []string{
-				`"data":{}`,
-			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
 		},
 		{
 			Name:   "different auth collection",
@@ -732,6 +794,27 @@ func TestRecordAuthConfirmVerification(t *testing.T) {
 				"OnRecordAfterConfirmVerificationRequest":  1,
 			},
 		},
+		{
+			Name:   "OnRecordAfterConfirmVerificationRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/collections/users/confirm-verification",
+			Body: strings.NewReader(`{
+				"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjRxMXhsY2xtZmxva3UzMyIsImVtYWlsIjoidGVzdEBleGFtcGxlLmNvbSIsImNvbGxlY3Rpb25JZCI6Il9wYl91c2Vyc19hdXRoXyIsInR5cGUiOiJhdXRoUmVjb3JkIiwiZXhwIjoyMjA4OTg1MjYxfQ.hL16TVmStHFdHLc4a860bRqJ3sFfzjv0_NRNzwsvsrc"
+			}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterConfirmVerificationRequest().Add(func(e *core.RecordConfirmVerificationEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelAfterUpdate":                       1,
+				"OnModelBeforeUpdate":                      1,
+				"OnRecordBeforeConfirmVerificationRequest": 1,
+				"OnRecordAfterConfirmVerificationRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -932,6 +1015,28 @@ func TestRecordAuthConfirmEmailChange(t *testing.T) {
 				`"token":{"code":"validation_token_collection_mismatch"`,
 			},
 		},
+		{
+			Name:   "OnRecordAfterConfirmEmailChangeRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/collections/users/confirm-email-change",
+			Body: strings.NewReader(`{
+				"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjRxMXhsY2xtZmxva3UzMyIsImNvbGxlY3Rpb25JZCI6Il9wYl91c2Vyc19hdXRoXyIsInR5cGUiOiJhdXRoUmVjb3JkIiwiZW1haWwiOiJ0ZXN0QGV4YW1wbGUuY29tIiwibmV3RW1haWwiOiJjaGFuZ2VAZXhhbXBsZS5jb20iLCJleHAiOjIyMDg5ODUyNjF9.1sG6cL708pRXXjiHRZhG-in0X5fnttSf5nNcadKoYRs",
+				"password":"1234567890"
+			}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterConfirmEmailChangeRequest().Add(func(e *core.RecordConfirmEmailChangeEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelAfterUpdate":                      1,
+				"OnModelBeforeUpdate":                     1,
+				"OnRecordBeforeConfirmEmailChangeRequest": 1,
+				"OnRecordAfterConfirmEmailChangeRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -1083,7 +1188,7 @@ func TestRecordAuthUnlinkExternalsAuth(t *testing.T) {
 				"OnRecordAfterUnlinkExternalAuthRequest":  1,
 				"OnRecordBeforeUnlinkExternalAuthRequest": 1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				record, err := app.Dao().FindRecordById("users", "4q1xlclmfloku33")
 				if err != nil {
 					t.Fatal(err)
@@ -1129,7 +1234,7 @@ func TestRecordAuthUnlinkExternalsAuth(t *testing.T) {
 				"OnRecordAfterUnlinkExternalAuthRequest":  1,
 				"OnRecordBeforeUnlinkExternalAuthRequest": 1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				record, err := app.Dao().FindRecordById("users", "4q1xlclmfloku33")
 				if err != nil {
 					t.Fatal(err)
@@ -1140,6 +1245,27 @@ func TestRecordAuthUnlinkExternalsAuth(t *testing.T) {
 				}
 			},
 		},
+		{
+			Name:   "OnRecordBeforeUnlinkExternalAuthRequest error response",
+			Method: http.MethodDelete,
+			Url:    "/api/collections/users/records/4q1xlclmfloku33/external-auths/google",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterUnlinkExternalAuthRequest().Add(func(e *core.RecordUnlinkExternalAuthEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelAfterDelete":                      1,
+				"OnModelBeforeDelete":                     1,
+				"OnRecordAfterUnlinkExternalAuthRequest":  1,
+				"OnRecordBeforeUnlinkExternalAuthRequest": 1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -1236,7 +1362,7 @@ func TestRecordAuthOAuth2Redirect(t *testing.T) {
 
 							expectedParams := []string{`"state"`, `"code"`}
 							for _, p := range expectedParams {
-								if !strings.Contains(msg.Data, p) {
+								if !strings.Contains(string(msg.Data), p) {
 									t.Errorf("Couldn't find %s in \n%v", p, msg.Data)
 								}
 							}

apis/record_crud.go

@@ -50,9 +50,9 @@ func (api *recordApi) list(c echo.Context) error {
 		return err
 	}
 
-	requestData := RequestData(c)
+	requestInfo := RequestInfo(c)
 
-	if requestData.Admin == nil && collection.ListRule == nil {
+	if requestInfo.Admin == nil && collection.ListRule == nil {
 		// only admins can access if the rule is nil
 		return NewForbiddenError("Only admins can perform this action.", nil)
 	}
@@ -60,15 +60,15 @@ func (api *recordApi) list(c echo.Context) error {
 	fieldsResolver := resolvers.NewRecordFieldResolver(
 		api.app.Dao(),
 		collection,
-		requestData,
+		requestInfo,
 		// hidden fields are searchable only by admins
-		requestData.Admin != nil,
+		requestInfo.Admin != nil,
 	)
 
 	searchProvider := search.NewProvider(fieldsResolver).
 		Query(api.app.Dao().RecordQuery(collection))
 
-	if requestData.Admin == nil && collection.ListRule != nil {
+	if requestInfo.Admin == nil && collection.ListRule != nil {
 		searchProvider.AddFilter(search.FilterData(*collection.ListRule))
 	}
 
@@ -86,6 +86,10 @@ func (api *recordApi) list(c echo.Context) error {
 	event.Result = result
 
 	return api.app.OnRecordsListRequest().Trigger(event, func(e *core.RecordsListEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		if err := EnrichRecords(e.HttpContext, api.app.Dao(), e.Records); err != nil && api.app.IsDebug() {
 			log.Println(err)
 		}
@@ -105,16 +109,16 @@ func (api *recordApi) view(c echo.Context) error {
 		return NewNotFoundError("", nil)
 	}
 
-	requestData := RequestData(c)
+	requestInfo := RequestInfo(c)
 
-	if requestData.Admin == nil && collection.ViewRule == nil {
+	if requestInfo.Admin == nil && collection.ViewRule == nil {
 		// only admins can access if the rule is nil
 		return NewForbiddenError("Only admins can perform this action.", nil)
 	}
 
 	ruleFunc := func(q *dbx.SelectQuery) error {
-		if requestData.Admin == nil && collection.ViewRule != nil && *collection.ViewRule != "" {
-			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestData, true)
+		if requestInfo.Admin == nil && collection.ViewRule != nil && *collection.ViewRule != "" {
+			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestInfo, true)
 			expr, err := search.FilterData(*collection.ViewRule).BuildExpr(resolver)
 			if err != nil {
 				return err
@@ -136,6 +140,10 @@ func (api *recordApi) view(c echo.Context) error {
 	event.Record = record
 
 	return api.app.OnRecordViewRequest().Trigger(event, func(e *core.RecordViewEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		if err := EnrichRecord(e.HttpContext, api.app.Dao(), e.Record); err != nil && api.app.IsDebug() {
 			log.Println(err)
 		}
@@ -150,23 +158,23 @@ func (api *recordApi) create(c echo.Context) error {
 		return NewNotFoundError("", "Missing collection context.")
 	}
 
-	requestData := RequestData(c)
+	requestInfo := RequestInfo(c)
 
-	if requestData.Admin == nil && collection.CreateRule == nil {
+	if requestInfo.Admin == nil && collection.CreateRule == nil {
 		// only admins can access if the rule is nil
 		return NewForbiddenError("Only admins can perform this action.", nil)
 	}
 
-	hasFullManageAccess := requestData.Admin != nil
+	hasFullManageAccess := requestInfo.Admin != nil
 
 	// temporary save the record and check it against the create rule
-	if requestData.Admin == nil && collection.CreateRule != nil {
+	if requestInfo.Admin == nil && collection.CreateRule != nil {
 		testRecord := models.NewRecord(collection)
 
 		// replace modifiers fields so that the resolved value is always
-		// available when accessing requestData.Data using just the field name
-		if requestData.HasModifierDataKeys() {
-			requestData.Data = testRecord.ReplaceModifers(requestData.Data)
+		// available when accessing requestInfo.Data using just the field name
+		if requestInfo.HasModifierDataKeys() {
+			requestInfo.Data = testRecord.ReplaceModifers(requestInfo.Data)
 		}
 
 		testForm := forms.NewRecordUpsert(api.app, testRecord)
@@ -180,7 +188,7 @@ func (api *recordApi) create(c echo.Context) error {
 				return nil // no create rule to resolve
 			}
 
-			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestData, true)
+			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestInfo, true)
 			expr, err := search.FilterData(*collection.CreateRule).BuildExpr(resolver)
 			if err != nil {
 				return err
@@ -195,7 +203,7 @@ func (api *recordApi) create(c echo.Context) error {
 			if err != nil {
 				return fmt.Errorf("DrySubmit create rule failure: %w", err)
 			}
-			hasFullManageAccess = hasAuthManageAccess(txDao, foundRecord, requestData)
+			hasFullManageAccess = hasAuthManageAccess(txDao, foundRecord, requestInfo)
 			return nil
 		})
 
@@ -220,7 +228,7 @@ func (api *recordApi) create(c echo.Context) error {
 	event.UploadedFiles = form.FilesToUpload()
 
 	// create the record
-	submitErr := form.Submit(func(next forms.InterceptorNextFunc[*models.Record]) forms.InterceptorNextFunc[*models.Record] {
+	return form.Submit(func(next forms.InterceptorNextFunc[*models.Record]) forms.InterceptorNextFunc[*models.Record] {
 		return func(m *models.Record) error {
 			event.Record = m
 
@@ -233,18 +241,16 @@ func (api *recordApi) create(c echo.Context) error {
 					log.Println(err)
 				}
 
-				return e.HttpContext.JSON(http.StatusOK, e.Record)
+				return api.app.OnRecordAfterCreateRequest().Trigger(event, func(e *core.RecordCreateEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.JSON(http.StatusOK, e.Record)
+				})
 			})
 		}
 	})
-
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterCreateRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return submitErr
 }
 
 func (api *recordApi) update(c echo.Context) error {
@@ -258,26 +264,26 @@ func (api *recordApi) update(c echo.Context) error {
 		return NewNotFoundError("", nil)
 	}
 
-	requestData := RequestData(c)
+	requestInfo := RequestInfo(c)
 
-	if requestData.Admin == nil && collection.UpdateRule == nil {
+	if requestInfo.Admin == nil && collection.UpdateRule == nil {
 		// only admins can access if the rule is nil
 		return NewForbiddenError("Only admins can perform this action.", nil)
 	}
 
 	// eager fetch the record so that the modifier field values are replaced
-	// and available when accessing requestData.Data using just the field name
-	if requestData.HasModifierDataKeys() {
+	// and available when accessing requestInfo.Data using just the field name
+	if requestInfo.HasModifierDataKeys() {
 		record, err := api.app.Dao().FindRecordById(collection.Id, recordId)
 		if err != nil || record == nil {
 			return NewNotFoundError("", err)
 		}
-		requestData.Data = record.ReplaceModifers(requestData.Data)
+		requestInfo.Data = record.ReplaceModifers(requestInfo.Data)
 	}
 
 	ruleFunc := func(q *dbx.SelectQuery) error {
-		if requestData.Admin == nil && collection.UpdateRule != nil && *collection.UpdateRule != "" {
-			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestData, true)
+		if requestInfo.Admin == nil && collection.UpdateRule != nil && *collection.UpdateRule != "" {
+			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestInfo, true)
 			expr, err := search.FilterData(*collection.UpdateRule).BuildExpr(resolver)
 			if err != nil {
 				return err
@@ -295,7 +301,7 @@ func (api *recordApi) update(c echo.Context) error {
 	}
 
 	form := forms.NewRecordUpsert(api.app, record)
-	form.SetFullManageAccess(requestData.Admin != nil || hasAuthManageAccess(api.app.Dao(), record, requestData))
+	form.SetFullManageAccess(requestInfo.Admin != nil || hasAuthManageAccess(api.app.Dao(), record, requestInfo))
 
 	// load request
 	if err := form.LoadRequest(c.Request(), ""); err != nil {
@@ -309,7 +315,7 @@ func (api *recordApi) update(c echo.Context) error {
 	event.UploadedFiles = form.FilesToUpload()
 
 	// update the record
-	submitErr := form.Submit(func(next forms.InterceptorNextFunc[*models.Record]) forms.InterceptorNextFunc[*models.Record] {
+	return form.Submit(func(next forms.InterceptorNextFunc[*models.Record]) forms.InterceptorNextFunc[*models.Record] {
 		return func(m *models.Record) error {
 			event.Record = m
 
@@ -322,18 +328,16 @@ func (api *recordApi) update(c echo.Context) error {
 					log.Println(err)
 				}
 
-				return e.HttpContext.JSON(http.StatusOK, e.Record)
+				return api.app.OnRecordAfterUpdateRequest().Trigger(event, func(e *core.RecordUpdateEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
+
+					return e.HttpContext.JSON(http.StatusOK, e.Record)
+				})
 			})
 		}
 	})
-
-	if submitErr == nil {
-		if err := api.app.OnRecordAfterUpdateRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return submitErr
 }
 
 func (api *recordApi) delete(c echo.Context) error {
@@ -347,16 +351,16 @@ func (api *recordApi) delete(c echo.Context) error {
 		return NewNotFoundError("", nil)
 	}
 
-	requestData := RequestData(c)
+	requestInfo := RequestInfo(c)
 
-	if requestData.Admin == nil && collection.DeleteRule == nil {
+	if requestInfo.Admin == nil && collection.DeleteRule == nil {
 		// only admins can access if the rule is nil
 		return NewForbiddenError("Only admins can perform this action.", nil)
 	}
 
 	ruleFunc := func(q *dbx.SelectQuery) error {
-		if requestData.Admin == nil && collection.DeleteRule != nil && *collection.DeleteRule != "" {
-			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestData, true)
+		if requestInfo.Admin == nil && collection.DeleteRule != nil && *collection.DeleteRule != "" {
+			resolver := resolvers.NewRecordFieldResolver(api.app.Dao(), collection, requestInfo, true)
 			expr, err := search.FilterData(*collection.DeleteRule).BuildExpr(resolver)
 			if err != nil {
 				return err
@@ -377,22 +381,20 @@ func (api *recordApi) delete(c echo.Context) error {
 	event.Collection = collection
 	event.Record = record
 
-	handlerErr := api.app.OnRecordBeforeDeleteRequest().Trigger(event, func(e *core.RecordDeleteEvent) error {
+	return api.app.OnRecordBeforeDeleteRequest().Trigger(event, func(e *core.RecordDeleteEvent) error {
 		// delete the record
 		if err := api.app.Dao().DeleteRecord(e.Record); err != nil {
 			return NewBadRequestError("Failed to delete record. Make sure that the record is not part of a required relation reference.", err)
 		}
 
-		return e.HttpContext.NoContent(http.StatusNoContent)
+		return api.app.OnRecordAfterDeleteRequest().Trigger(event, func(e *core.RecordDeleteEvent) error {
+			if e.HttpContext.Response().Committed {
+				return nil
+			}
+
+			return e.HttpContext.NoContent(http.StatusNoContent)
+		})
 	})
-
-	if handlerErr == nil {
-		if err := api.app.OnRecordAfterDeleteRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return handlerErr
 }
 
 func (api *recordApi) checkForForbiddenQueryFields(c echo.Context) error {

apis/record_crud_test.go

@@ -1,6 +1,7 @@
 package apis_test
 
 import (
+	"errors"
 	"net/http"
 	"net/url"
 	"os"
@@ -10,6 +11,7 @@ import (
 	"time"
 
 	"github.com/labstack/echo/v5"
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/tests"
 )
@@ -460,6 +462,22 @@ func TestRecordCrudList(t *testing.T) {
 			},
 			ExpectedEvents: map[string]int{"OnRecordsListRequest": 1},
 		},
+		{
+			Name:           "view collection with numeric ids",
+			Method:         http.MethodGet,
+			Url:            "/api/collections/numeric_id_view/records",
+			ExpectedStatus: 200,
+			ExpectedContent: []string{
+				`"page":1`,
+				`"perPage":30`,
+				`"totalPages":1`,
+				`"totalItems":2`,
+				`"items":[{`,
+				`"id":"1"`,
+				`"id":"2"`,
+			},
+			ExpectedEvents: map[string]int{"OnRecordsListRequest": 1},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -729,6 +747,16 @@ func TestRecordCrudView(t *testing.T) {
 			},
 			ExpectedEvents: map[string]int{"OnRecordViewRequest": 1},
 		},
+		{
+			Name:           "view record with numeric id",
+			Method:         http.MethodGet,
+			Url:            "/api/collections/numeric_id_view/records/1",
+			ExpectedStatus: 200,
+			ExpectedContent: []string{
+				`"id":"1"`,
+			},
+			ExpectedEvents: map[string]int{"OnRecordViewRequest": 1},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -836,6 +864,27 @@ func TestRecordCrudDelete(t *testing.T) {
 				"OnRecordBeforeDeleteRequest": 1,
 			},
 		},
+		{
+			Name:   "OnRecordAfterDeleteRequest error response",
+			Method: http.MethodDelete,
+			Url:    "/api/collections/clients/records/o1y0dd0spd786md",
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterDeleteRequest().Add(func(e *core.RecordDeleteEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelAfterDelete":          1,
+				"OnModelBeforeDelete":         1,
+				"OnRecordAfterDeleteRequest":  1,
+				"OnRecordBeforeDeleteRequest": 1,
+			},
+		},
 		{
 			Name:   "authenticated record that match the collection delete rule",
 			Method: http.MethodDelete,
@@ -854,7 +903,7 @@ func TestRecordCrudDelete(t *testing.T) {
 				"OnRecordAfterDeleteRequest":  1,
 				"OnRecordBeforeDeleteRequest": 1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				ensureDeletedFiles(app, "_pb_users_auth_", "4q1xlclmfloku33")
 
 				// check if all the external auths records were deleted
@@ -941,7 +990,7 @@ func TestRecordCrudDelete(t *testing.T) {
 				"OnRecordBeforeDeleteRequest": 1,
 				"OnRecordAfterDeleteRequest":  1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				recId := "84nmscqy84lsi1t"
 				rec, _ := app.Dao().FindRecordById("demo1", recId, nil)
 				if rec != nil {
@@ -1187,6 +1236,25 @@ func TestRecordCrudCreate(t *testing.T) {
 				`"code":"validation_not_unique"`,
 			},
 		},
+		{
+			Name:   "OnRecordAfterCreateRequest error response",
+			Method: http.MethodPost,
+			Url:    "/api/collections/demo2/records",
+			Body:   strings.NewReader(`{"title":"new"}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterCreateRequest().Add(func(e *core.RecordCreateEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnRecordBeforeCreateRequest": 1,
+				"OnRecordAfterCreateRequest":  1,
+				"OnModelBeforeCreate":         1,
+				"OnModelAfterCreate":          1,
+			},
+		},
 
 		// ID checks
 		// -----------------------------------------------------------
@@ -1745,6 +1813,25 @@ func TestRecordCrudUpdate(t *testing.T) {
 				"OnModelAfterUpdate":          1,
 			},
 		},
+		{
+			Name:   "OnRecordAfterUpdateRequest error response",
+			Method: http.MethodPatch,
+			Url:    "/api/collections/demo2/records/0yxhwia2amd8gec",
+			Body:   strings.NewReader(`{"title":"new"}`),
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnRecordAfterUpdateRequest().Add(func(e *core.RecordUpdateEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnRecordBeforeUpdateRequest": 1,
+				"OnRecordAfterUpdateRequest":  1,
+				"OnModelBeforeUpdate":         1,
+				"OnModelAfterUpdate":          1,
+			},
+		},
 		{
 			Name:   "try to change the id of an existing record",
 			Method: http.MethodPatch,
@@ -1945,7 +2032,7 @@ func TestRecordCrudUpdate(t *testing.T) {
 				"OnRecordAfterUpdateRequest":  1,
 				"OnRecordBeforeUpdateRequest": 1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				record, _ := app.Dao().FindRecordById("nologin", "phhq3wr65cap535")
 				if !record.ValidatePassword("12345678") {
 					t.Fatal("Password update failed.")
@@ -1988,7 +2075,7 @@ func TestRecordCrudUpdate(t *testing.T) {
 				"OnRecordAfterUpdateRequest":  1,
 				"OnRecordBeforeUpdateRequest": 1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				record, _ := app.Dao().FindRecordById("users", "oap640cot4yru2s")
 				if !record.ValidatePassword("12345678") {
 					t.Fatal("Password update failed.")
@@ -2050,7 +2137,7 @@ func TestRecordCrudUpdate(t *testing.T) {
 				"OnRecordAfterUpdateRequest":  1,
 				"OnRecordBeforeUpdateRequest": 1,
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				record, _ := app.Dao().FindRecordById("nologin", "dc49k6jgejn40h3")
 				if !record.ValidatePassword("123456789") {
 					t.Fatal("Password update failed.")

apis/record_helpers.go

@@ -17,19 +17,28 @@ import (
 	"github.com/pocketbase/pocketbase/tools/search"
 )
 
-const ContextRequestDataKey = "requestData"
+const ContextRequestInfoKey = "requestInfo"
 
-// RequestData exports cached common request data fields
+// Deprecated: Use RequestInfo instead.
+func RequestData(c echo.Context) *models.RequestInfo {
+	log.Println("RequestData(c) is deprecated and will be removed in the future! You can replace it with RequestInfo(c).")
+	return RequestInfo(c)
+}
+
+// RequestInfo exports cached common request data fields
 // (query, body, logged auth state, etc.) from the provided context.
-func RequestData(c echo.Context) *models.RequestData {
+func RequestInfo(c echo.Context) *models.RequestInfo {
 	// return cached to avoid copying the body multiple times
-	if v := c.Get(ContextRequestDataKey); v != nil {
-		if data, ok := v.(*models.RequestData); ok {
+	if v := c.Get(ContextRequestInfoKey); v != nil {
+		if data, ok := v.(*models.RequestInfo); ok {
+			// refresh auth state
+			data.AuthRecord, _ = c.Get(ContextAuthRecordKey).(*models.Record)
+			data.Admin, _ = c.Get(ContextAdminKey).(*models.Admin)
 			return data
 		}
 	}
 
-	result := &models.RequestData{
+	result := &models.RequestInfo{
 		Method:  c.Request().Method,
 		Query:   map[string]any{},
 		Data:    map[string]any{},
@@ -49,12 +58,20 @@ func RequestData(c echo.Context) *models.RequestData {
 	echo.BindQueryParams(c, &result.Query)
 	rest.BindBody(c, &result.Data)
 
-	c.Set(ContextRequestDataKey, result)
+	c.Set(ContextRequestInfoKey, result)
 
 	return result
 }
 
-func RecordAuthResponse(app core.App, c echo.Context, authRecord *models.Record, meta any) error {
+// RecordAuthResponse writes standardised json record auth response
+// into the specified request context.
+func RecordAuthResponse(
+	app core.App,
+	c echo.Context,
+	authRecord *models.Record,
+	meta any,
+	finalizers ...func(token string) error,
+) error {
 	token, tokenErr := tokens.NewRecordAuthToken(app, authRecord)
 	if tokenErr != nil {
 		return NewBadRequestError("Failed to create auth token.", tokenErr)
@@ -68,6 +85,10 @@ func RecordAuthResponse(app core.App, c echo.Context, authRecord *models.Record,
 	event.Meta = meta
 
 	return app.OnRecordAuthRequest().Trigger(event, func(e *core.RecordAuthEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		// allow always returning the email address of the authenticated account
 		e.Record.IgnoreEmailVisibility(true)
 
@@ -75,13 +96,13 @@ func RecordAuthResponse(app core.App, c echo.Context, authRecord *models.Record,
 		expands := strings.Split(c.QueryParam(expandQueryParam), ",")
 		if len(expands) > 0 {
 			// create a copy of the cached request data and adjust it to the current auth record
-			requestData := *RequestData(e.HttpContext)
-			requestData.Admin = nil
-			requestData.AuthRecord = e.Record
+			requestInfo := *RequestInfo(e.HttpContext)
+			requestInfo.Admin = nil
+			requestInfo.AuthRecord = e.Record
 			failed := app.Dao().ExpandRecord(
 				e.Record,
 				expands,
-				expandFetch(app.Dao(), &requestData),
+				expandFetch(app.Dao(), &requestInfo),
 			)
 			if len(failed) > 0 && app.IsDebug() {
 				log.Println("Failed to expand relations: ", failed)
@@ -97,6 +118,12 @@ func RecordAuthResponse(app core.App, c echo.Context, authRecord *models.Record,
 			result["meta"] = e.Meta
 		}
 
+		for _, f := range finalizers {
+			if err := f(e.Token); err != nil {
+				return err
+			}
+		}
+
 		return e.HttpContext.JSON(http.StatusOK, result)
 	})
 }
@@ -114,9 +141,9 @@ func EnrichRecord(c echo.Context, dao *daos.Dao, record *models.Record, defaultE
 //   - ensures that the emails of the auth records and their expanded auth relations
 //     are visibe only for the current logged admin, record owner or record with manage access
 func EnrichRecords(c echo.Context, dao *daos.Dao, records []*models.Record, defaultExpands ...string) error {
-	requestData := RequestData(c)
+	requestInfo := RequestInfo(c)
 
-	if err := autoIgnoreAuthRecordsEmailVisibility(dao, records, requestData); err != nil {
+	if err := autoIgnoreAuthRecordsEmailVisibility(dao, records, requestInfo); err != nil {
 		return fmt.Errorf("Failed to resolve email visibility: %w", err)
 	}
 
@@ -128,7 +155,7 @@ func EnrichRecords(c echo.Context, dao *daos.Dao, records []*models.Record, defa
 		return nil // nothing to expand
 	}
 
-	errs := dao.ExpandRecords(records, expands, expandFetch(dao, requestData))
+	errs := dao.ExpandRecords(records, expands, expandFetch(dao, requestInfo))
 	if len(errs) > 0 {
 		return fmt.Errorf("Failed to expand: %v", errs)
 	}
@@ -139,11 +166,11 @@ func EnrichRecords(c echo.Context, dao *daos.Dao, records []*models.Record, defa
 // expandFetch is the records fetch function that is used to expand related records.
 func expandFetch(
 	dao *daos.Dao,
-	requestData *models.RequestData,
+	requestInfo *models.RequestInfo,
 ) daos.ExpandFetchFunc {
 	return func(relCollection *models.Collection, relIds []string) ([]*models.Record, error) {
 		records, err := dao.FindRecordsByIds(relCollection.Id, relIds, func(q *dbx.SelectQuery) error {
-			if requestData.Admin != nil {
+			if requestInfo.Admin != nil {
 				return nil // admins can access everything
 			}
 
@@ -152,7 +179,7 @@ func expandFetch(
 			}
 
 			if *relCollection.ViewRule != "" {
-				resolver := resolvers.NewRecordFieldResolver(dao, relCollection, requestData, true)
+				resolver := resolvers.NewRecordFieldResolver(dao, relCollection, requestInfo, true)
 				expr, err := search.FilterData(*(relCollection.ViewRule)).BuildExpr(resolver)
 				if err != nil {
 					return err
@@ -165,7 +192,7 @@ func expandFetch(
 		})
 
 		if err == nil && len(records) > 0 {
-			autoIgnoreAuthRecordsEmailVisibility(dao, records, requestData)
+			autoIgnoreAuthRecordsEmailVisibility(dao, records, requestInfo)
 		}
 
 		return records, err
@@ -179,13 +206,13 @@ func expandFetch(
 func autoIgnoreAuthRecordsEmailVisibility(
 	dao *daos.Dao,
 	records []*models.Record,
-	requestData *models.RequestData,
+	requestInfo *models.RequestInfo,
 ) error {
 	if len(records) == 0 || !records[0].Collection().IsAuth() {
 		return nil // nothing to check
 	}
 
-	if requestData.Admin != nil {
+	if requestInfo.Admin != nil {
 		for _, rec := range records {
 			rec.IgnoreEmailVisibility(true)
 		}
@@ -201,8 +228,8 @@ func autoIgnoreAuthRecordsEmailVisibility(
 		recordIds[i] = rec.Id
 	}
 
-	if requestData != nil && requestData.AuthRecord != nil && mappedRecords[requestData.AuthRecord.Id] != nil {
-		mappedRecords[requestData.AuthRecord.Id].IgnoreEmailVisibility(true)
+	if requestInfo != nil && requestInfo.AuthRecord != nil && mappedRecords[requestInfo.AuthRecord.Id] != nil {
+		mappedRecords[requestInfo.AuthRecord.Id].IgnoreEmailVisibility(true)
 	}
 
 	authOptions := collection.AuthOptions()
@@ -218,7 +245,7 @@ func autoIgnoreAuthRecordsEmailVisibility(
 		Select(dao.DB().QuoteSimpleColumnName(collection.Name) + ".id").
 		AndWhere(dbx.In(dao.DB().QuoteSimpleColumnName(collection.Name)+".id", recordIds...))
 
-	resolver := resolvers.NewRecordFieldResolver(dao, collection, requestData, true)
+	resolver := resolvers.NewRecordFieldResolver(dao, collection, requestInfo, true)
 	expr, err := search.FilterData(*authOptions.ManageRule).BuildExpr(resolver)
 	if err != nil {
 		return err
@@ -247,7 +274,7 @@ func autoIgnoreAuthRecordsEmailVisibility(
 func hasAuthManageAccess(
 	dao *daos.Dao,
 	record *models.Record,
-	requestData *models.RequestData,
+	requestInfo *models.RequestInfo,
 ) bool {
 	if !record.Collection().IsAuth() {
 		return false
@@ -259,12 +286,12 @@ func hasAuthManageAccess(
 		return false // only for admins (manageRule can't be empty)
 	}
 
-	if requestData == nil || requestData.AuthRecord == nil {
+	if requestInfo == nil || requestInfo.AuthRecord == nil {
 		return false // no auth record
 	}
 
 	ruleFunc := func(q *dbx.SelectQuery) error {
-		resolver := resolvers.NewRecordFieldResolver(dao, record.Collection(), requestData, true)
+		resolver := resolvers.NewRecordFieldResolver(dao, record.Collection(), requestInfo, true)
 		expr, err := search.FilterData(*manageRule).BuildExpr(resolver)
 		if err != nil {
 			return err

apis/record_helpers_test.go

@@ -13,7 +13,7 @@ import (
 	"github.com/pocketbase/pocketbase/tests"
 )
 
-func TestRequestData(t *testing.T) {
+func TestRequestInfo(t *testing.T) {
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodPost, "/?test=123", strings.NewReader(`{"test":456}`))
 	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
@@ -29,10 +29,10 @@ func TestRequestData(t *testing.T) {
 	dummyAdmin.Id = "id2"
 	c.Set(apis.ContextAdminKey, dummyAdmin)
 
-	result := apis.RequestData(c)
+	result := apis.RequestInfo(c)
 
 	if result == nil {
-		t.Fatal("Expected *models.RequestData instance, got nil")
+		t.Fatal("Expected *models.RequestInfo instance, got nil")
 	}
 
 	if result.Method != http.MethodPost {

apis/serve.go

@@ -11,38 +11,60 @@ import (
 	"time"
 
 	"github.com/fatih/color"
+	"github.com/labstack/echo/v5"
 	"github.com/labstack/echo/v5/middleware"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/migrations"
 	"github.com/pocketbase/pocketbase/migrations/logs"
+	"github.com/pocketbase/pocketbase/tools/list"
 	"github.com/pocketbase/pocketbase/tools/migrate"
 	"golang.org/x/crypto/acme"
 	"golang.org/x/crypto/acme/autocert"
 )
 
-// ServeOptions defines an optional struct for apis.Serve().
-type ServeOptions struct {
+// ServeConfig defines a configuration struct for apis.Serve().
+type ServeConfig struct {
+	// ShowStartBanner indicates whether to show or hide the server start console message.
 	ShowStartBanner bool
-	HttpAddr        string
-	HttpsAddr       string
-	AllowedOrigins  []string // optional list of CORS origins (default to "*")
-	BeforeServeFunc func(server *http.Server) error
+
+	// HttpAddr is the TCP address to listen for the HTTP server (eg. `127.0.0.1:80`).
+	HttpAddr string
+
+	// HttpsAddr is the TCP address to listen for the HTTPS server (eg. `127.0.0.1:443`).
+	HttpsAddr string
+
+	// Optional domains list to use when issuing the TLS certificate.
+	//
+	// If not set, the host from the bound server address will be used.
+	//
+	// For convenience, for each "non-www" domain a "www" entry and
+	// redirect will be automatically added.
+	CertificateDomains []string
+
+	// AllowedOrigins is an optional list of CORS origins (default to "*").
+	AllowedOrigins []string
 }
 
 // Serve starts a new app web server.
-func Serve(app core.App, options *ServeOptions) error {
-	if options == nil {
-		options = &ServeOptions{}
-	}
-
-	if len(options.AllowedOrigins) == 0 {
-		options.AllowedOrigins = []string{"*"}
+//
+// NB! The app should be bootstrapped before starting the web server.
+//
+// Example:
+//
+// 	app.Bootstrap()
+// 	apis.Serve(app, apis.ServeConfig{
+// 		HttpAddr:        "127.0.0.1:8080",
+// 		ShowStartBanner: false,
+// 	})
+func Serve(app core.App, config ServeConfig) (*http.Server, error) {
+	if len(config.AllowedOrigins) == 0 {
+		config.AllowedOrigins = []string{"*"}
 	}
 
 	// ensure that the latest migrations are applied before starting the server
 	if err := runMigrations(app); err != nil {
-		return err
+		return nil, err
 	}
 
 	// reload app settings in case a new default value was set with a migration
@@ -56,33 +78,70 @@ func Serve(app core.App, options *ServeOptions) error {
 
 	router, err := InitApi(app)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// configure cors
 	router.Use(middleware.CORSWithConfig(middleware.CORSConfig{
 		Skipper:      middleware.DefaultSkipper,
-		AllowOrigins: options.AllowedOrigins,
+		AllowOrigins: config.AllowedOrigins,
 		AllowMethods: []string{http.MethodGet, http.MethodHead, http.MethodPut, http.MethodPatch, http.MethodPost, http.MethodDelete},
 	}))
 
 	// start http server
 	// ---
-	mainAddr := options.HttpAddr
-	if options.HttpsAddr != "" {
-		mainAddr = options.HttpsAddr
+	mainAddr := config.HttpAddr
+	if config.HttpsAddr != "" {
+		mainAddr = config.HttpsAddr
 	}
 
-	mainHost, _, _ := net.SplitHostPort(mainAddr)
+	var wwwRedirects []string
 
-	certManager := autocert.Manager{
+	// extract the host names for the certificate host policy
+	hostNames := config.CertificateDomains
+	if len(hostNames) == 0 {
+		host, _, _ := net.SplitHostPort(mainAddr)
+		hostNames = append(hostNames, host)
+	}
+	for _, host := range hostNames {
+		if strings.HasPrefix(host, "www.") {
+			continue // explicitly set www host
+		}
+
+		wwwHost := "www." + host
+		if !list.ExistInSlice(wwwHost, hostNames) {
+			hostNames = append(hostNames, wwwHost)
+			wwwRedirects = append(wwwRedirects, wwwHost)
+		}
+	}
+
+	// implicit www->non-www redirect(s)
+	if len(wwwRedirects) > 0 {
+		router.Pre(func(next echo.HandlerFunc) echo.HandlerFunc {
+			return func(c echo.Context) error {
+				host := c.Request().Host
+
+				if strings.HasPrefix(host, "www.") && list.ExistInSlice(host, wwwRedirects) {
+					return c.Redirect(
+						http.StatusTemporaryRedirect,
+						(c.Scheme() + "://" + host[4:] + c.Request().RequestURI),
+					)
+				}
+
+				return next(c)
+			}
+		})
+	}
+
+	certManager := &autocert.Manager{
 		Prompt:     autocert.AcceptTOS,
 		Cache:      autocert.DirCache(filepath.Join(app.DataDir(), ".autocert_cache")),
-		HostPolicy: autocert.HostWhitelist(mainHost, "www."+mainHost),
+		HostPolicy: autocert.HostWhitelist(hostNames...),
 	}
 
-	serverConfig := &http.Server{
+	server := &http.Server{
 		TLSConfig: &tls.Config{
+			MinVersion:     tls.VersionTLS12,
 			GetCertificate: certManager.GetCertificate,
 			NextProtos:     []string{acme.ALPNProto},
 		},
@@ -93,16 +152,26 @@ func Serve(app core.App, options *ServeOptions) error {
 		Addr:    mainAddr,
 	}
 
-	if options.BeforeServeFunc != nil {
-		if err := options.BeforeServeFunc(serverConfig); err != nil {
-			return err
-		}
+	serveEvent := &core.ServeEvent{
+		App:         app,
+		Router:      router,
+		Server:      server,
+		CertManager: certManager,
+	}
+	if err := app.OnBeforeServe().Trigger(serveEvent); err != nil {
+		return nil, err
 	}
 
-	if options.ShowStartBanner {
+	if config.ShowStartBanner {
 		schema := "http"
-		if options.HttpsAddr != "" {
+		addr := server.Addr
+
+		if config.HttpsAddr != "" {
 			schema = "https"
+
+			if len(config.CertificateDomains) > 0 {
+				addr = config.CertificateDomains[0]
+			}
 		}
 
 		date := new(strings.Builder)
@@ -112,34 +181,34 @@ func Serve(app core.App, options *ServeOptions) error {
 		bold.Printf(
 			"%s Server started at %s\n",
 			strings.TrimSpace(date.String()),
-			color.CyanString("%s://%s", schema, serverConfig.Addr),
+			color.CyanString("%s://%s", schema, addr),
 		)
 
 		regular := color.New()
-		regular.Printf(" ➜ REST API: %s\n", color.CyanString("%s://%s/api/", schema, serverConfig.Addr))
-		regular.Printf(" ➜ Admin UI: %s\n", color.CyanString("%s://%s/_/", schema, serverConfig.Addr))
+		regular.Printf("├─ REST API: %s\n", color.CyanString("%s://%s/api/", schema, addr))
+		regular.Printf("└─ Admin UI: %s\n", color.CyanString("%s://%s/_/", schema, addr))
 	}
 
 	// try to gracefully shutdown the server on app termination
 	app.OnTerminate().Add(func(e *core.TerminateEvent) error {
 		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 		defer cancel()
-		serverConfig.Shutdown(ctx)
+		server.Shutdown(ctx)
 		return nil
 	})
 
 	// start HTTPS server
-	if options.HttpsAddr != "" {
+	if config.HttpsAddr != "" {
 		// if httpAddr is set, start an HTTP server to redirect the traffic to the HTTPS version
-		if options.HttpAddr != "" {
-			go http.ListenAndServe(options.HttpAddr, certManager.HTTPHandler(nil))
+		if config.HttpAddr != "" {
+			go http.ListenAndServe(config.HttpAddr, certManager.HTTPHandler(nil))
 		}
 
-		return serverConfig.ListenAndServeTLS("", "")
+		return server, server.ListenAndServeTLS("", "")
 	}
 
 	// OR start HTTP server
-	return serverConfig.ListenAndServe()
+	return server, server.ListenAndServe()
 }
 
 type migrationsConnection struct {

apis/settings.go

@@ -1,7 +1,6 @@
 package apis
 
 import (
-	"log"
 	"net/http"
 
 	validation "github.com/go-ozzo/ozzo-validation/v4"
@@ -38,6 +37,10 @@ func (api *settingsApi) list(c echo.Context) error {
 	event.RedactedSettings = settings
 
 	return api.app.OnSettingsListRequest().Trigger(event, func(e *core.SettingsListEvent) error {
+		if e.HttpContext.Response().Committed {
+			return nil
+		}
+
 		return e.HttpContext.JSON(http.StatusOK, e.RedactedSettings)
 	})
 }
@@ -55,7 +58,7 @@ func (api *settingsApi) set(c echo.Context) error {
 	event.OldSettings = api.app.Settings()
 
 	// update the settings
-	submitErr := form.Submit(func(next forms.InterceptorNextFunc[*settings.Settings]) forms.InterceptorNextFunc[*settings.Settings] {
+	return form.Submit(func(next forms.InterceptorNextFunc[*settings.Settings]) forms.InterceptorNextFunc[*settings.Settings] {
 		return func(s *settings.Settings) error {
 			event.NewSettings = s
 
@@ -64,23 +67,21 @@ func (api *settingsApi) set(c echo.Context) error {
 					return NewBadRequestError("An error occurred while submitting the form.", err)
 				}
 
-				redactedSettings, err := api.app.Settings().RedactClone()
-				if err != nil {
-					return NewBadRequestError("", err)
-				}
+				return api.app.OnSettingsAfterUpdateRequest().Trigger(event, func(e *core.SettingsUpdateEvent) error {
+					if e.HttpContext.Response().Committed {
+						return nil
+					}
 
-				return e.HttpContext.JSON(http.StatusOK, redactedSettings)
+					redactedSettings, err := api.app.Settings().RedactClone()
+					if err != nil {
+						return NewBadRequestError("", err)
+					}
+
+					return e.HttpContext.JSON(http.StatusOK, redactedSettings)
+				})
 			})
 		}
 	})
-
-	if submitErr == nil {
-		if err := api.app.OnSettingsAfterUpdateRequest().Trigger(event); err != nil && api.app.IsDebug() {
-			log.Println(err)
-		}
-	}
-
-	return submitErr
 }
 
 func (api *settingsApi) testS3(c echo.Context) error {

apis/settings_test.go

@@ -6,12 +6,14 @@ import (
 	"crypto/rand"
 	"crypto/x509"
 	"encoding/pem"
+	"errors"
 	"fmt"
 	"net/http"
 	"strings"
 	"testing"
 
 	"github.com/labstack/echo/v5"
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tests"
 )
 
@@ -75,6 +77,11 @@ func TestSettingsList(t *testing.T) {
 				`"oidc2Auth":{`,
 				`"oidc3Auth":{`,
 				`"appleAuth":{`,
+				`"instagramAuth":{`,
+				`"vkAuth":{`,
+				`"yandexAuth":{`,
+				`"patreonAuth":{`,
+				`"mailcowAuth":{`,
 				`"secret":"******"`,
 				`"clientSecret":"******"`,
 			},
@@ -153,6 +160,11 @@ func TestSettingsSet(t *testing.T) {
 				`"oidc2Auth":{`,
 				`"oidc3Auth":{`,
 				`"appleAuth":{`,
+				`"instagramAuth":{`,
+				`"vkAuth":{`,
+				`"yandexAuth":{`,
+				`"patreonAuth":{`,
+				`"mailcowAuth":{`,
 				`"secret":"******"`,
 				`"clientSecret":"******"`,
 				`"appName":"acme_test"`,
@@ -220,6 +232,11 @@ func TestSettingsSet(t *testing.T) {
 				`"oidc2Auth":{`,
 				`"oidc3Auth":{`,
 				`"appleAuth":{`,
+				`"instagramAuth":{`,
+				`"vkAuth":{`,
+				`"yandexAuth":{`,
+				`"patreonAuth":{`,
+				`"mailcowAuth":{`,
 				`"secret":"******"`,
 				`"clientSecret":"******"`,
 				`"appName":"update_test"`,
@@ -231,6 +248,28 @@ func TestSettingsSet(t *testing.T) {
 				"OnSettingsAfterUpdateRequest":  1,
 			},
 		},
+		{
+			Name:   "OnSettingsAfterUpdateRequest error response",
+			Method: http.MethodPatch,
+			Url:    "/api/settings",
+			Body:   strings.NewReader(validData),
+			RequestHeaders: map[string]string{
+				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
+			},
+			BeforeTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+				app.OnSettingsAfterUpdateRequest().Add(func(e *core.SettingsUpdateEvent) error {
+					return errors.New("error")
+				})
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{`"data":{}`},
+			ExpectedEvents: map[string]int{
+				"OnModelBeforeUpdate":           1,
+				"OnModelAfterUpdate":            1,
+				"OnSettingsBeforeUpdateRequest": 1,
+				"OnSettingsAfterUpdateRequest":  1,
+			},
+		},
 	}
 
 	for _, scenario := range scenarios {
@@ -367,7 +406,7 @@ func TestSettingsTestEmail(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				if app.TestMailer.TotalSend != 1 {
 					t.Fatalf("[verification] Expected 1 sent email, got %d", app.TestMailer.TotalSend)
 				}
@@ -402,7 +441,7 @@ func TestSettingsTestEmail(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				if app.TestMailer.TotalSend != 1 {
 					t.Fatalf("[password-reset] Expected 1 sent email, got %d", app.TestMailer.TotalSend)
 				}
@@ -437,7 +476,7 @@ func TestSettingsTestEmail(t *testing.T) {
 			RequestHeaders: map[string]string{
 				"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InN5d2JoZWNuaDQ2cmhtMCIsInR5cGUiOiJhZG1pbiIsImV4cCI6MjIwODk4NTI2MX0.M1m--VOqGyv0d23eeUc0r9xE8ZzHaYVmVFw1VZW6gT8",
 			},
-			AfterTestFunc: func(t *testing.T, app *tests.TestApp, e *echo.Echo) {
+			AfterTestFunc: func(t *testing.T, app *tests.TestApp, res *http.Response) {
 				if app.TestMailer.TotalSend != 1 {
 					t.Fatalf("[email-change] Expected 1 sent email, got %d", app.TestMailer.TotalSend)
 				}

cmd/serve.go

@@ -17,14 +17,30 @@ func NewServeCommand(app core.App, showStartBanner bool) *cobra.Command {
 	var httpsAddr string
 
 	command := &cobra.Command{
-		Use:   "serve",
-		Short: "Starts the web server (default to 127.0.0.1:8090)",
+		Use:   "serve [domain(s)]",
+		Args:  cobra.ArbitraryArgs,
+		Short: "Starts the web server (default to 127.0.0.1:8090 if no domain is specified)",
 		Run: func(command *cobra.Command, args []string) {
-			err := apis.Serve(app, &apis.ServeOptions{
-				HttpAddr:        httpAddr,
-				HttpsAddr:       httpsAddr,
-				ShowStartBanner: showStartBanner,
-				AllowedOrigins:  allowedOrigins,
+			// set default listener addresses if at least one domain is specified
+			if len(args) > 0 {
+				if httpAddr == "" {
+					httpAddr = "0.0.0.0:80"
+				}
+				if httpsAddr == "" {
+					httpsAddr = "0.0.0.0:443"
+				}
+			} else {
+				if httpAddr == "" {
+					httpAddr = "127.0.0.1:8090"
+				}
+			}
+
+			_, err := apis.Serve(app, apis.ServeConfig{
+				HttpAddr:           httpAddr,
+				HttpsAddr:          httpsAddr,
+				ShowStartBanner:    showStartBanner,
+				AllowedOrigins:     allowedOrigins,
+				CertificateDomains: args,
 			})
 
 			if err != http.ErrServerClosed {
@@ -43,15 +59,15 @@ func NewServeCommand(app core.App, showStartBanner bool) *cobra.Command {
 	command.PersistentFlags().StringVar(
 		&httpAddr,
 		"http",
-		"127.0.0.1:8090",
-		"api HTTP server address",
+		"",
+		"TCP address to listen for the HTTP server\n(if domain args are specified - default to 0.0.0.0:80, otherwise - default to 127.0.0.1:8090)",
 	)
 
 	command.PersistentFlags().StringVar(
 		&httpsAddr,
 		"https",
 		"",
-		"api HTTPS server address (auto TLS via Let's Encrypt)\nthe incoming --http address traffic also will be redirected to this address",
+		"TCP address to listen for the HTTPS server\n(if domain args are specified - default to 0.0.0.0:443, otherwise - default to empty string, aka. no TLS)\nThe incoming HTTP traffic also will be auto redirected to the HTTPS version",
 	)
 
 	return command

core/app.go

@@ -74,14 +74,14 @@ type App interface {
 	// NewFilesystem creates and returns a configured filesystem.System instance
 	// for managing regular app files (eg. collection uploads).
 	//
-	// NB! Make sure to call `Close()` on the returned result
+	// NB! Make sure to call Close() on the returned result
 	// after you are done working with it.
 	NewFilesystem() (*filesystem.System, error)
 
 	// NewBackupsFilesystem creates and returns a configured filesystem.System instance
 	// for managing app backups.
 	//
-	// NB! Make sure to call `Close()` on the returned result
+	// NB! Make sure to call Close() on the returned result
 	// after you are done working with it.
 	NewBackupsFilesystem() (*filesystem.System, error)
 
@@ -131,21 +131,21 @@ type App interface {
 	// App event hooks
 	// ---------------------------------------------------------------
 
-	// OnBeforeBootstrap hook is triggered before initializing the base
+	// OnBeforeBootstrap hook is triggered before initializing the main
 	// application resources (eg. before db open and initial settings load).
 	OnBeforeBootstrap() *hook.Hook[*BootstrapEvent]
 
-	// OnAfterBootstrap hook is triggered after initializing the base
+	// OnAfterBootstrap hook is triggered after initializing the main
 	// application resources (eg. after db open and initial settings load).
 	OnAfterBootstrap() *hook.Hook[*BootstrapEvent]
 
 	// OnBeforeServe hook is triggered before serving the internal router (echo),
-	// allowing you to adjust its options and attach new routes.
+	// allowing you to adjust its options and attach new routes or middlewares.
 	OnBeforeServe() *hook.Hook[*ServeEvent]
 
 	// OnBeforeApiError hook is triggered right before sending an error API
 	// response to the client, allowing you to further modify the error data
-	// or to return a completely different API response (using [hook.StopPropagation]).
+	// or to return a completely different API response.
 	OnBeforeApiError() *hook.Hook[*ApiErrorEvent]
 
 	// OnAfterApiError hook is triggered right after sending an error API
@@ -162,7 +162,7 @@ type App interface {
 	// ---------------------------------------------------------------
 
 	// OnModelBeforeCreate hook is triggered before inserting a new
-	// entry in the DB, allowing you to modify or validate the stored data.
+	// model in the DB, allowing you to modify or validate the stored data.
 	//
 	// If the optional "tags" list (table names and/or the Collection id for Record models)
 	// is specified, then all event handlers registered via the created hook
@@ -170,7 +170,7 @@ type App interface {
 	OnModelBeforeCreate(tags ...string) *hook.TaggedHook[*ModelEvent]
 
 	// OnModelAfterCreate hook is triggered after successfully
-	// inserting a new entry in the DB.
+	// inserting a new model in the DB.
 	//
 	// If the optional "tags" list (table names and/or the Collection id for Record models)
 	// is specified, then all event handlers registered via the created hook
@@ -178,7 +178,7 @@ type App interface {
 	OnModelAfterCreate(tags ...string) *hook.TaggedHook[*ModelEvent]
 
 	// OnModelBeforeUpdate hook is triggered before updating existing
-	// entry in the DB, allowing you to modify or validate the stored data.
+	// model in the DB, allowing you to modify or validate the stored data.
 	//
 	// If the optional "tags" list (table names and/or the Collection id for Record models)
 	// is specified, then all event handlers registered via the created hook
@@ -186,7 +186,7 @@ type App interface {
 	OnModelBeforeUpdate(tags ...string) *hook.TaggedHook[*ModelEvent]
 
 	// OnModelAfterUpdate hook is triggered after successfully updating
-	// existing entry in the DB.
+	// existing model in the DB.
 	//
 	// If the optional "tags" list (table names and/or the Collection id for Record models)
 	// is specified, then all event handlers registered via the created hook
@@ -194,15 +194,15 @@ type App interface {
 	OnModelAfterUpdate(tags ...string) *hook.TaggedHook[*ModelEvent]
 
 	// OnModelBeforeDelete hook is triggered before deleting an
-	// existing entry from the DB.
+	// existing model from the DB.
 	//
 	// If the optional "tags" list (table names and/or the Collection id for Record models)
 	// is specified, then all event handlers registered via the created hook
 	// will be triggered and called only if their event data origin matches the tags.
 	OnModelBeforeDelete(tags ...string) *hook.TaggedHook[*ModelEvent]
 
-	// OnModelAfterDelete is triggered after successfully deleting an
-	// existing entry from the DB.
+	// OnModelAfterDelete hook is triggered after successfully deleting an
+	// existing model from the DB.
 	//
 	// If the optional "tags" list (table names and/or the Collection id for Record models)
 	// is specified, then all event handlers registered via the created hook
@@ -213,22 +213,18 @@ type App interface {
 	// Mailer event hooks
 	// ---------------------------------------------------------------
 
-	// OnMailerBeforeAdminResetPasswordSend hook is triggered right before
-	// sending a password reset email to an admin.
-	//
-	// Could be used to send your own custom email template if
-	// [hook.StopPropagation] is returned in one of its listeners.
+	// OnMailerBeforeAdminResetPasswordSend hook is triggered right
+	// before sending a password reset email to an admin, allowing you
+	// to inspect and customize the email message that is being sent.
 	OnMailerBeforeAdminResetPasswordSend() *hook.Hook[*MailerAdminEvent]
 
 	// OnMailerAfterAdminResetPasswordSend hook is triggered after
 	// admin password reset email was successfully sent.
 	OnMailerAfterAdminResetPasswordSend() *hook.Hook[*MailerAdminEvent]
 
-	// OnMailerBeforeRecordResetPasswordSend hook is triggered right before
-	// sending a password reset email to an auth record.
-	//
-	// Could be used to send your own custom email template if
-	// [hook.StopPropagation] is returned in one of its listeners.
+	// OnMailerBeforeRecordResetPasswordSend hook is triggered right
+	// before sending a password reset email to an auth record, allowing
+	// you to inspect and customize the email message that is being sent.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -243,11 +239,9 @@ type App interface {
 	// triggered and called only if their event data origin matches the tags.
 	OnMailerAfterRecordResetPasswordSend(tags ...string) *hook.TaggedHook[*MailerRecordEvent]
 
-	// OnMailerBeforeRecordVerificationSend hook is triggered right before
-	// sending a verification email to an auth record.
-	//
-	// Could be used to send your own custom email template if
-	// [hook.StopPropagation] is returned in one of its listeners.
+	// OnMailerBeforeRecordVerificationSend hook is triggered right
+	// before sending a verification email to an auth record, allowing
+	// you to inspect and customize the email message that is being sent.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -263,10 +257,8 @@ type App interface {
 	OnMailerAfterRecordVerificationSend(tags ...string) *hook.TaggedHook[*MailerRecordEvent]
 
 	// OnMailerBeforeRecordChangeEmailSend hook is triggered right before
-	// sending a confirmation new address email to an auth record.
-	//
-	// Could be used to send your own custom email template if
-	// [hook.StopPropagation] is returned in one of its listeners.
+	// sending a confirmation new address email to an auth record, allowing
+	// you to inspect and customize the email message that is being sent.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -328,8 +320,7 @@ type App interface {
 	// Settings update request (after request data load and before settings persistence).
 	//
 	// Could be used to additionally validate the request data or
-	// implement completely different persistence behavior
-	// (returning [hook.StopPropagation]).
+	// implement completely different persistence behavior.
 	OnSettingsBeforeUpdateRequest() *hook.Hook[*SettingsUpdateEvent]
 
 	// OnSettingsAfterUpdateRequest hook is triggered after each
@@ -383,7 +374,7 @@ type App interface {
 	// Admin create request (after request data load and before model persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	OnAdminBeforeCreateRequest() *hook.Hook[*AdminCreateEvent]
 
 	// OnAdminAfterCreateRequest hook is triggered after each
@@ -394,7 +385,7 @@ type App interface {
 	// Admin update request (after request data load and before model persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	OnAdminBeforeUpdateRequest() *hook.Hook[*AdminUpdateEvent]
 
 	// OnAdminAfterUpdateRequest hook is triggered after each
@@ -405,7 +396,7 @@ type App interface {
 	// Admin delete request (after model load and before actual deletion).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different delete behavior (returning [hook.StopPropagation]).
+	// completely different delete behavior.
 	OnAdminBeforeDeleteRequest() *hook.Hook[*AdminDeleteEvent]
 
 	// OnAdminAfterDeleteRequest hook is triggered after each
@@ -434,7 +425,7 @@ type App interface {
 	// auth refresh API request (right before generating a new auth token).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different auth refresh behavior (returning [hook.StopPropagation]).
+	// completely different auth refresh behavior.
 	OnAdminBeforeAuthRefreshRequest() *hook.Hook[*AdminAuthRefreshEvent]
 
 	// OnAdminAfterAuthRefreshRequest hook is triggered after each
@@ -445,7 +436,7 @@ type App interface {
 	// request password reset API request (after request data load and before sending the reset email).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different password reset behavior (returning [hook.StopPropagation]).
+	// completely different password reset behavior.
 	OnAdminBeforeRequestPasswordResetRequest() *hook.Hook[*AdminRequestPasswordResetEvent]
 
 	// OnAdminAfterRequestPasswordResetRequest hook is triggered after each
@@ -456,7 +447,7 @@ type App interface {
 	// confirm password reset API request (after request data load and before persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	OnAdminBeforeConfirmPasswordResetRequest() *hook.Hook[*AdminConfirmPasswordResetEvent]
 
 	// OnAdminAfterConfirmPasswordResetRequest hook is triggered after each
@@ -482,7 +473,7 @@ type App interface {
 	// auth with password API request (after request data load and before password validation).
 	//
 	// Could be used to implement for example a custom password validation
-	// or to locate a different Record identity (by assigning [RecordAuthWithPasswordEvent.Record]).
+	// or to locate a different Record model (by reassigning [RecordAuthWithPasswordEvent.Record]).
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -500,11 +491,11 @@ type App interface {
 	// OnRecordBeforeAuthWithOAuth2Request hook is triggered before each Record
 	// OAuth2 sign-in/sign-up API request (after token exchange and before external provider linking).
 	//
-	// If the [RecordAuthWithOAuth2Event.Record] is nil, then the OAuth2
+	// If the [RecordAuthWithOAuth2Event.Record] is not set, then the OAuth2
 	// request will try to create a new auth Record.
 	//
 	// To assign or link a different existing record model you can
-	// overwrite/modify the [RecordAuthWithOAuth2Event.Record] field.
+	// change the [RecordAuthWithOAuth2Event.Record] field.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -523,7 +514,7 @@ type App interface {
 	// auth refresh API request (right before generating a new auth token).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different auth refresh behavior (returning [hook.StopPropagation]).
+	// completely different auth refresh behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -538,11 +529,39 @@ type App interface {
 	// triggered and called only if their event data origin matches the tags.
 	OnRecordAfterAuthRefreshRequest(tags ...string) *hook.TaggedHook[*RecordAuthRefreshEvent]
 
+	// OnRecordListExternalAuthsRequest hook is triggered on each API record external auths list request.
+	//
+	// Could be used to validate or modify the response before returning it to the client.
+	//
+	// If the optional "tags" list (Collection ids or names) is specified,
+	// then all event handlers registered via the created hook will be
+	// triggered and called only if their event data origin matches the tags.
+	OnRecordListExternalAuthsRequest(tags ...string) *hook.TaggedHook[*RecordListExternalAuthsEvent]
+
+	// OnRecordBeforeUnlinkExternalAuthRequest hook is triggered before each API record
+	// external auth unlink request (after models load and before the actual relation deletion).
+	//
+	// Could be used to additionally validate the request data or implement
+	// completely different delete behavior.
+	//
+	// If the optional "tags" list (Collection ids or names) is specified,
+	// then all event handlers registered via the created hook will be
+	// triggered and called only if their event data origin matches the tags.
+	OnRecordBeforeUnlinkExternalAuthRequest(tags ...string) *hook.TaggedHook[*RecordUnlinkExternalAuthEvent]
+
+	// OnRecordAfterUnlinkExternalAuthRequest hook is triggered after each
+	// successful API record external auth unlink request.
+	//
+	// If the optional "tags" list (Collection ids or names) is specified,
+	// then all event handlers registered via the created hook will be
+	// triggered and called only if their event data origin matches the tags.
+	OnRecordAfterUnlinkExternalAuthRequest(tags ...string) *hook.TaggedHook[*RecordUnlinkExternalAuthEvent]
+
 	// OnRecordBeforeRequestPasswordResetRequest hook is triggered before each Record
 	// request password reset API request (after request data load and before sending the reset email).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different password reset behavior (returning [hook.StopPropagation]).
+	// completely different password reset behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -561,7 +580,7 @@ type App interface {
 	// confirm password reset API request (after request data load and before persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -580,7 +599,7 @@ type App interface {
 	// request verification API request (after request data load and before sending the verification email).
 	//
 	// Could be used to additionally validate the loaded request data or implement
-	// completely different verification behavior (returning [hook.StopPropagation]).
+	// completely different verification behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -599,7 +618,7 @@ type App interface {
 	// confirm verification API request (after request data load and before persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -618,7 +637,7 @@ type App interface {
 	// (after request data load and before sending the email link to confirm the change).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different request email change behavior (returning [hook.StopPropagation]).
+	// completely different request email change behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -637,7 +656,7 @@ type App interface {
 	// confirm email change API request (after request data load and before persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -652,34 +671,6 @@ type App interface {
 	// triggered and called only if their event data origin matches the tags.
 	OnRecordAfterConfirmEmailChangeRequest(tags ...string) *hook.TaggedHook[*RecordConfirmEmailChangeEvent]
 
-	// OnRecordListExternalAuthsRequest hook is triggered on each API record external auths list request.
-	//
-	// Could be used to validate or modify the response before returning it to the client.
-	//
-	// If the optional "tags" list (Collection ids or names) is specified,
-	// then all event handlers registered via the created hook will be
-	// triggered and called only if their event data origin matches the tags.
-	OnRecordListExternalAuthsRequest(tags ...string) *hook.TaggedHook[*RecordListExternalAuthsEvent]
-
-	// OnRecordBeforeUnlinkExternalAuthRequest hook is triggered before each API record
-	// external auth unlink request (after models load and before the actual relation deletion).
-	//
-	// Could be used to additionally validate the request data or implement
-	// completely different delete behavior (returning [hook.StopPropagation]).
-	//
-	// If the optional "tags" list (Collection ids or names) is specified,
-	// then all event handlers registered via the created hook will be
-	// triggered and called only if their event data origin matches the tags.
-	OnRecordBeforeUnlinkExternalAuthRequest(tags ...string) *hook.TaggedHook[*RecordUnlinkExternalAuthEvent]
-
-	// OnRecordAfterUnlinkExternalAuthRequest hook is triggered after each
-	// successful API record external auth unlink request.
-	//
-	// If the optional "tags" list (Collection ids or names) is specified,
-	// then all event handlers registered via the created hook will be
-	// triggered and called only if their event data origin matches the tags.
-	OnRecordAfterUnlinkExternalAuthRequest(tags ...string) *hook.TaggedHook[*RecordUnlinkExternalAuthEvent]
-
 	// ---------------------------------------------------------------
 	// Record CRUD API event hooks
 	// ---------------------------------------------------------------
@@ -706,7 +697,7 @@ type App interface {
 	// create request (after request data load and before model persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -725,7 +716,7 @@ type App interface {
 	// update request (after request data load and before model persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -744,7 +735,7 @@ type App interface {
 	// delete request (after model load and before actual deletion).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different delete behavior (returning [hook.StopPropagation]).
+	// completely different delete behavior.
 	//
 	// If the optional "tags" list (Collection ids or names) is specified,
 	// then all event handlers registered via the created hook will be
@@ -777,7 +768,7 @@ type App interface {
 	// create request (after request data load and before model persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	OnCollectionBeforeCreateRequest() *hook.Hook[*CollectionCreateEvent]
 
 	// OnCollectionAfterCreateRequest hook is triggered after each
@@ -788,7 +779,7 @@ type App interface {
 	// update request (after request data load and before model persistence).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different persistence behavior (returning [hook.StopPropagation]).
+	// completely different persistence behavior.
 	OnCollectionBeforeUpdateRequest() *hook.Hook[*CollectionUpdateEvent]
 
 	// OnCollectionAfterUpdateRequest hook is triggered after each
@@ -799,7 +790,7 @@ type App interface {
 	// Collection delete request (after model load and before actual deletion).
 	//
 	// Could be used to additionally validate the request data or implement
-	// completely different delete behavior (returning [hook.StopPropagation]).
+	// completely different delete behavior.
 	OnCollectionBeforeDeleteRequest() *hook.Hook[*CollectionDeleteEvent]
 
 	// OnCollectionAfterDeleteRequest hook is triggered after each
@@ -810,7 +801,7 @@ type App interface {
 	// collections import request (after request data load and before the actual import).
 	//
 	// Could be used to additionally validate the imported collections or
-	// to implement completely different import behavior (returning [hook.StopPropagation]).
+	// to implement completely different import behavior.
 	OnCollectionsBeforeImportRequest() *hook.Hook[*CollectionsImportEvent]
 
 	// OnCollectionsAfterImportRequest hook is triggered after each

core/base.go

@@ -180,7 +180,7 @@ type BaseAppConfig struct {
 // configured with the provided arguments.
 //
 // To initialize the app, you need to call `app.Bootstrap()`.
-func NewBaseApp(config *BaseAppConfig) *BaseApp {
+func NewBaseApp(config BaseAppConfig) *BaseApp {
 	app := &BaseApp{
 		dataDir:             config.DataDir,
 		isDebug:             config.IsDebug,
@@ -349,11 +349,7 @@ func (app *BaseApp) Bootstrap() error {
 	// cleanup the pb_data temp directory (if any)
 	os.RemoveAll(filepath.Join(app.DataDir(), LocalTempDirName))
 
-	if err := app.OnAfterBootstrap().Trigger(event); err != nil && app.IsDebug() {
-		log.Println(err)
-	}
-
-	return nil
+	return app.OnAfterBootstrap().Trigger(event)
 }
 
 // ResetBootstrapState takes care for releasing initialized app resources
@@ -379,7 +375,6 @@ func (app *BaseApp) ResetBootstrapState() error {
 
 	app.dao = nil
 	app.logsDao = nil
-	app.settings = nil
 
 	return nil
 }
@@ -475,6 +470,7 @@ func (app *BaseApp) NewMailClient() mailer.Mailer {
 			Password:   app.Settings().Smtp.Password,
 			Tls:        app.Settings().Smtp.Tls,
 			AuthMethod: app.Settings().Smtp.AuthMethod,
+			LocalName:  app.Settings().Smtp.LocalName,
 		}
 	}
 
@@ -485,7 +481,7 @@ func (app *BaseApp) NewMailClient() mailer.Mailer {
 // for managing regular app files (eg. collection uploads)
 // based on the current app settings.
 //
-// NB! Make sure to call `Close()` on the returned result
+// NB! Make sure to call Close() on the returned result
 // after you are done working with it.
 func (app *BaseApp) NewFilesystem() (*filesystem.System, error) {
 	if app.settings != nil && app.settings.S3.Enabled {
@@ -506,7 +502,7 @@ func (app *BaseApp) NewFilesystem() (*filesystem.System, error) {
 // NewFilesystem creates a new local or S3 filesystem instance
 // for managing app backups based on the current app settings.
 //
-// NB! Make sure to call `Close()` on the returned result
+// NB! Make sure to call Close() on the returned result
 // after you are done working with it.
 func (app *BaseApp) NewBackupsFilesystem() (*filesystem.System, error) {
 	if app.settings != nil && app.settings.Backups.S3.Enabled {
@@ -1053,58 +1049,58 @@ func (app *BaseApp) initDataDB() error {
 func (app *BaseApp) createDaoWithHooks(concurrentDB, nonconcurrentDB dbx.Builder) *daos.Dao {
 	dao := daos.NewMultiDB(concurrentDB, nonconcurrentDB)
 
-	dao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	dao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		e := new(ModelEvent)
 		e.Dao = eventDao
 		e.Model = m
 
-		return app.OnModelBeforeCreate().Trigger(e)
+		return app.OnModelBeforeCreate().Trigger(e, func(e *ModelEvent) error {
+			return action()
+		})
 	}
 
-	dao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) {
+	dao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		e := new(ModelEvent)
 		e.Dao = eventDao
 		e.Model = m
 
-		if err := app.OnModelAfterCreate().Trigger(e); err != nil && app.isDebug {
-			log.Println(err)
-		}
+		return app.OnModelAfterCreate().Trigger(e)
 	}
 
-	dao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	dao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		e := new(ModelEvent)
 		e.Dao = eventDao
 		e.Model = m
 
-		return app.OnModelBeforeUpdate().Trigger(e)
+		return app.OnModelBeforeUpdate().Trigger(e, func(e *ModelEvent) error {
+			return action()
+		})
 	}
 
-	dao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) {
+	dao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		e := new(ModelEvent)
 		e.Dao = eventDao
 		e.Model = m
 
-		if err := app.OnModelAfterUpdate().Trigger(e); err != nil && app.isDebug {
-			log.Println(err)
-		}
+		return app.OnModelAfterUpdate().Trigger(e)
 	}
 
-	dao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+	dao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		e := new(ModelEvent)
 		e.Dao = eventDao
 		e.Model = m
 
-		return app.OnModelBeforeDelete().Trigger(e)
+		return app.OnModelBeforeDelete().Trigger(e, func(e *ModelEvent) error {
+			return action()
+		})
 	}
 
-	dao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) {
+	dao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
 		e := new(ModelEvent)
 		e.Dao = eventDao
 		e.Model = m
 
-		if err := app.OnModelAfterDelete().Trigger(e); err != nil && app.isDebug {
-			log.Println(err)
-		}
+		return app.OnModelAfterDelete().Trigger(e)
 	}
 
 	return dao

core/base_backup.go

@@ -17,6 +17,7 @@ import (
 	"github.com/pocketbase/pocketbase/tools/archive"
 	"github.com/pocketbase/pocketbase/tools/cron"
 	"github.com/pocketbase/pocketbase/tools/filesystem"
+	"github.com/pocketbase/pocketbase/tools/inflector"
 	"github.com/pocketbase/pocketbase/tools/osutils"
 	"github.com/pocketbase/pocketbase/tools/security"
 )
@@ -31,6 +32,9 @@ const CacheKeyActiveBackup string = "@activeBackup"
 // The backup is executed within a transaction, meaning that new writes
 // will be temporary "blocked" until the backup file is generated.
 //
+// To safely perform the backup, it is recommended to have free disk space
+// for at least 2x the size of the pb_data directory.
+//
 // By default backups are stored in pb_data/backups
 // (the backups directory itself is excluded from the generated backup).
 //
@@ -43,27 +47,31 @@ func (app *BaseApp) CreateBackup(ctx context.Context, name string) error {
 		return errors.New("try again later - another backup/restore operation has already been started")
 	}
 
-	// auto generate backup name
 	if name == "" {
-		name = fmt.Sprintf(
-			"pb_backup_%s.zip",
-			time.Now().UTC().Format("20060102150405"),
-		)
+		name = app.generateBackupName("pb_backup_")
 	}
 
 	app.Cache().Set(CacheKeyActiveBackup, name)
 	defer app.Cache().Remove(CacheKeyActiveBackup)
 
-	// Archive pb_data in a temp directory, exluding the "backups" dir itself (if exist).
+	// root dir entries to exclude from the backup generation
+	exclude := []string{LocalBackupsDirName, LocalTempDirName}
+
+	// make sure that the special temp directory exists
+	// note: it needs to be inside the current pb_data to avoid "cross-device link" errors
+	localTempDir := filepath.Join(app.DataDir(), LocalTempDirName)
+	if err := os.MkdirAll(localTempDir, os.ModePerm); err != nil {
+		return fmt.Errorf("failed to create a temp dir: %w", err)
+	}
+
+	// Archive pb_data in a temp directory, exluding the "backups" and the temp dirs.
 	//
 	// Run in transaction to temporary block other writes (transactions uses the NonconcurrentDB connection).
 	// ---
-	tempPath := filepath.Join(os.TempDir(), "pb_backup_"+security.PseudorandomString(4))
+	tempPath := filepath.Join(localTempDir, "pb_backup_"+security.PseudorandomString(4))
 	createErr := app.Dao().RunInTransaction(func(txDao *daos.Dao) error {
-		if err := archive.Create(app.DataDir(), tempPath, LocalBackupsDirName); err != nil {
-			return err
-		}
-		return nil
+		// @todo consider experimenting with temp switching the readonly pragma after the db interface change
+		return archive.Create(app.DataDir(), tempPath, exclude...)
 	})
 	if createErr != nil {
 		return createErr
@@ -118,7 +126,7 @@ func (app *BaseApp) CreateBackup(ctx context.Context, name string) error {
 //
 //  4. Move the extracted dir content to the app "pb_data".
 //
-//  5. Restart the app (on successfull app bootstap it will also remove the old pb_data).
+//  5. Restart the app (on successful app bootstap it will also remove the old pb_data).
 //
 // If a failure occure during the restore process the dir changes are reverted.
 // If for whatever reason the revert is not possible, it panics.
@@ -149,7 +157,15 @@ func (app *BaseApp) RestoreBackup(ctx context.Context, name string) error {
 	}
 	defer br.Close()
 
-	tempZip, err := os.CreateTemp(os.TempDir(), "pb_restore")
+	// make sure that the special temp directory exists
+	// note: it needs to be inside the current pb_data to avoid "cross-device link" errors
+	localTempDir := filepath.Join(app.DataDir(), LocalTempDirName)
+	if err := os.MkdirAll(localTempDir, os.ModePerm); err != nil {
+		return fmt.Errorf("failed to create a temp dir: %w", err)
+	}
+
+	// create a temp zip file from the blob.Reader and try to extract it
+	tempZip, err := os.CreateTemp(localTempDir, "pb_restore_zip")
 	if err != nil {
 		return err
 	}
@@ -159,13 +175,7 @@ func (app *BaseApp) RestoreBackup(ctx context.Context, name string) error {
 		return err
 	}
 
-	// make sure that the special temp directory
-	if err := os.MkdirAll(filepath.Join(app.DataDir(), LocalTempDirName), os.ModePerm); err != nil {
-		return fmt.Errorf("failed to create a temp dir: %w", err)
-	}
-
-	// note: it needs to be inside the current pb_data to avoid "cross-device link" errors
-	extractedDataDir := filepath.Join(app.DataDir(), LocalTempDirName, "pb_restore_"+security.PseudorandomString(4))
+	extractedDataDir := filepath.Join(localTempDir, "pb_restore_"+security.PseudorandomString(4))
 	defer os.RemoveAll(extractedDataDir)
 	if err := archive.Extract(tempZip.Name(), extractedDataDir); err != nil {
 		return err
@@ -189,7 +199,7 @@ func (app *BaseApp) RestoreBackup(ctx context.Context, name string) error {
 	// move the current pb_data content to a special temp location
 	// that will hold the old data between dirs replace
 	// (the temp dir will be automatically removed on the next app start)
-	oldTempDataDir := filepath.Join(app.DataDir(), LocalTempDirName, "old_pb_data_" + security.PseudorandomString(4))
+	oldTempDataDir := filepath.Join(localTempDir, "old_pb_data_"+security.PseudorandomString(4))
 	if err := osutils.MoveDirContent(app.DataDir(), oldTempDataDir, exclude...); err != nil {
 		return fmt.Errorf("failed to move the current pb_data content to a temp location: %w", err)
 	}
@@ -224,7 +234,6 @@ func (app *BaseApp) RestoreBackup(ctx context.Context, name string) error {
 }
 
 // initAutobackupHooks registers the autobackup app serve hooks.
-// @todo add tests
 func (app *BaseApp) initAutobackupHooks() error {
 	c := cron.New()
 	isServe := false
@@ -238,13 +247,9 @@ func (app *BaseApp) initAutobackupHooks() error {
 		}
 
 		c.Add("@autobackup", rawSchedule, func() {
-			autoPrefix := "@auto_pb_backup_"
+			const autoPrefix = "@auto_pb_backup_"
 
-			name := fmt.Sprintf(
-				"%s%s.zip",
-				autoPrefix,
-				time.Now().UTC().Format("20060102150405"),
-			)
+			name := app.generateBackupName(autoPrefix)
 
 			if err := app.CreateBackup(context.Background(), name); err != nil && app.IsDebug() {
 				// @todo replace after logs generalization
@@ -323,3 +328,17 @@ func (app *BaseApp) initAutobackupHooks() error {
 
 	return nil
 }
+
+func (app *BaseApp) generateBackupName(prefix string) string {
+	appName := inflector.Snakecase(app.Settings().Meta.AppName)
+	if len(appName) > 50 {
+		appName = appName[:50]
+	}
+
+	return fmt.Sprintf(
+		"%s%s_%s.zip",
+		prefix,
+		appName,
+		time.Now().UTC().Format("20060102150405"),
+	)
+}

core/base_backup_test.go

@@ -19,6 +19,11 @@ func TestCreateBackup(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
+	// set some long app name with spaces and special characters
+	app.Settings().Meta.AppName = "test @! " + strings.Repeat("a", 100)
+
+	expectedAppNamePrefix := "test_" + strings.Repeat("a", 45)
+
 	// test pending error
 	app.Cache().Set(core.CacheKeyActiveBackup, "")
 	if err := app.CreateBackup(context.Background(), "test.zip"); err == nil {
@@ -49,8 +54,8 @@ func TestCreateBackup(t *testing.T) {
 	}
 
 	expectedFiles := []string{
-		`^pb_backup_\w+\.zip$`,
-		`^pb_backup_\w+\.zip.attrs$`,
+		`^pb_backup_` + expectedAppNamePrefix + `_\w+\.zip$`,
+		`^pb_backup_` + expectedAppNamePrefix + `_\w+\.zip.attrs$`,
 		"custom",
 		"custom.attrs",
 	}
@@ -81,6 +86,12 @@ func TestRestoreBackup(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
+	// create a initial test backup to ensure that there are at least 1
+	// backup file and that the generated zip doesn't contain the backups dir
+	if err := app.CreateBackup(context.Background(), "initial"); err != nil {
+		t.Fatal("Failed to create test initial backup")
+	}
+
 	// create test backup
 	if err := app.CreateBackup(context.Background(), "test"); err != nil {
 		t.Fatal("Failed to create test backup")

core/base_test.go

@@ -11,7 +11,7 @@ func TestNewBaseApp(t *testing.T) {
 	const testDataDir = "./pb_base_app_test_data_dir/"
 	defer os.RemoveAll(testDataDir)
 
-	app := NewBaseApp(&BaseAppConfig{
+	app := NewBaseApp(BaseAppConfig{
 		DataDir:       testDataDir,
 		EncryptionEnv: "test_env",
 		IsDebug:       true,
@@ -46,7 +46,7 @@ func TestBaseAppBootstrap(t *testing.T) {
 	const testDataDir = "./pb_base_app_test_data_dir/"
 	defer os.RemoveAll(testDataDir)
 
-	app := NewBaseApp(&BaseAppConfig{
+	app := NewBaseApp(BaseAppConfig{
 		DataDir:       testDataDir,
 		EncryptionEnv: "pb_test_env",
 		IsDebug:       false,
@@ -118,17 +118,13 @@ func TestBaseAppBootstrap(t *testing.T) {
 	if app.logsDao != nil {
 		t.Fatalf("Expected app.logsDao to be nil, got %v.", app.logsDao)
 	}
-
-	if app.settings != nil {
-		t.Fatalf("Expected app.settings to be nil, got %v.", app.settings)
-	}
 }
 
 func TestBaseAppGetters(t *testing.T) {
 	const testDataDir = "./pb_base_app_test_data_dir/"
 	defer os.RemoveAll(testDataDir)
 
-	app := NewBaseApp(&BaseAppConfig{
+	app := NewBaseApp(BaseAppConfig{
 		DataDir:       testDataDir,
 		EncryptionEnv: "pb_test_env",
 		IsDebug:       false,
@@ -188,7 +184,7 @@ func TestBaseAppNewMailClient(t *testing.T) {
 	const testDataDir = "./pb_base_app_test_data_dir/"
 	defer os.RemoveAll(testDataDir)
 
-	app := NewBaseApp(&BaseAppConfig{
+	app := NewBaseApp(BaseAppConfig{
 		DataDir:       testDataDir,
 		EncryptionEnv: "pb_test_env",
 		IsDebug:       false,
@@ -211,7 +207,7 @@ func TestBaseAppNewFilesystem(t *testing.T) {
 	const testDataDir = "./pb_base_app_test_data_dir/"
 	defer os.RemoveAll(testDataDir)
 
-	app := NewBaseApp(&BaseAppConfig{
+	app := NewBaseApp(BaseAppConfig{
 		DataDir:       testDataDir,
 		EncryptionEnv: "pb_test_env",
 		IsDebug:       false,
@@ -241,7 +237,7 @@ func TestBaseAppNewBackupsFilesystem(t *testing.T) {
 	const testDataDir = "./pb_base_app_test_data_dir/"
 	defer os.RemoveAll(testDataDir)
 
-	app := NewBaseApp(&BaseAppConfig{
+	app := NewBaseApp(BaseAppConfig{
 		DataDir:       testDataDir,
 		EncryptionEnv: "pb_test_env",
 		IsDebug:       false,

core/db.go

@@ -1,20 +0,0 @@
-package core
-
-import (
-	"github.com/pocketbase/dbx"
-)
-
-func initPragmas(db *dbx.DB) error {
-	// note: the busy_timeout pragma must be first because
-	// the connection needs to be set to block on busy before WAL mode
-	// is set in case it hasn't been already set by another connection
-	_, err := db.NewQuery(`
-		PRAGMA busy_timeout       = 10000;
-		PRAGMA journal_mode       = WAL;
-		PRAGMA journal_size_limit = 200000000;
-		PRAGMA synchronous        = NORMAL;
-		PRAGMA foreign_keys       = TRUE;
-	`).Execute()
-
-	return err
-}

core/db_cgo.go

@@ -3,18 +3,46 @@
 package core
 
 import (
+	"database/sql"
+
+	"github.com/mattn/go-sqlite3"
 	"github.com/pocketbase/dbx"
-	_ "github.com/mattn/go-sqlite3"
 )
 
-func connectDB(dbPath string) (*dbx.DB, error) {
-	db, err := dbx.Open("sqlite3", dbPath)
-	if err != nil {
-		return nil, err
-	}
+func init() {
+	// Registers the sqlite3 driver with a ConnectHook so that we can
+	// initialize the default PRAGMAs.
+	//
+	// Note 1: we don't define the PRAGMA as part of the dsn string
+	// because not all pragmas are available.
+	//
+	// Note 2: the busy_timeout pragma must be first because
+	// the connection needs to be set to block on busy before WAL mode
+	// is set in case it hasn't been already set by another connection.
+	sql.Register("pb_sqlite3",
+		&sqlite3.SQLiteDriver{
+			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+				_, err := conn.Exec(`
+					PRAGMA busy_timeout       = 10000;
+					PRAGMA journal_mode       = WAL;
+					PRAGMA journal_size_limit = 200000000;
+					PRAGMA synchronous        = NORMAL;
+					PRAGMA foreign_keys       = ON;
+					PRAGMA temp_store         = MEMORY;
+					PRAGMA cache_size         = -16000;
+				`, nil)
 
-	if err := initPragmas(db); err != nil {
-		db.Close()
+				return err
+			},
+		},
+	)
+
+	dbx.BuilderFuncMap["pb_sqlite3"] = dbx.BuilderFuncMap["sqlite3"]
+}
+
+func connectDB(dbPath string) (*dbx.DB, error) {
+	db, err := dbx.Open("pb_sqlite3", dbPath)
+	if err != nil {
 		return nil, err
 	}
 

core/db_nocgo.go

@@ -8,13 +8,13 @@ import (
 )
 
 func connectDB(dbPath string) (*dbx.DB, error) {
-	db, err := dbx.Open("sqlite", dbPath)
-	if err != nil {
-		return nil, err
-	}
+	// Note: the busy_timeout pragma must be first because
+	// the connection needs to be set to block on busy before WAL mode
+	// is set in case it hasn't been already set by another connection.
+	pragmas := "?_pragma=busy_timeout(10000)&_pragma=journal_mode(WAL)&_pragma=journal_size_limit(200000000)&_pragma=synchronous(NORMAL)&_pragma=foreign_keys(ON)&_pragma=temp_store(MEMORY)&_pragma=cache_size(-16000)"
 
-	if err := initPragmas(db); err != nil {
-		db.Close()
+	db, err := dbx.Open("sqlite", dbPath+pragmas)
+	if err != nil {
 		return nil, err
 	}
 

core/events.go

@@ -1,6 +1,9 @@
 package core
 
 import (
+	"net/http"
+	"time"
+
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/models"
@@ -12,6 +15,7 @@ import (
 	"github.com/pocketbase/pocketbase/tools/mailer"
 	"github.com/pocketbase/pocketbase/tools/search"
 	"github.com/pocketbase/pocketbase/tools/subscriptions"
+	"golang.org/x/crypto/acme/autocert"
 )
 
 var (
@@ -70,8 +74,10 @@ type TerminateEvent struct {
 }
 
 type ServeEvent struct {
-	App    App
-	Router *echo.Echo
+	App         App
+	Router      *echo.Echo
+	Server      *http.Server
+	CertManager *autocert.Manager
 }
 
 type ApiErrorEvent struct {
@@ -116,6 +122,7 @@ type MailerAdminEvent struct {
 type RealtimeConnectEvent struct {
 	HttpContext echo.Context
 	Client      subscriptions.Client
+	IdleTimeout time.Duration
 }
 
 type RealtimeDisconnectEvent struct {

daos/base.go

@@ -5,6 +5,8 @@ package daos
 
 import (
 	"errors"
+	"fmt"
+	"strings"
 	"time"
 
 	"github.com/pocketbase/dbx"
@@ -29,7 +31,8 @@ func NewMultiDB(concurrentDB, nonconcurrentDB dbx.Builder) *Dao {
 }
 
 // Dao handles various db operations.
-// Think of Dao as a repository and service layer in one.
+//
+// You can think of Dao as a repository and service layer in one.
 type Dao struct {
 	// in a transaction both refer to the same *dbx.TX instance
 	concurrentDB    dbx.Builder
@@ -43,12 +46,13 @@ type Dao struct {
 	// This field has no effect if an explicit query context is already specified.
 	ModelQueryTimeout time.Duration
 
-	BeforeCreateFunc func(eventDao *Dao, m models.Model) error
-	AfterCreateFunc  func(eventDao *Dao, m models.Model)
-	BeforeUpdateFunc func(eventDao *Dao, m models.Model) error
-	AfterUpdateFunc  func(eventDao *Dao, m models.Model)
-	BeforeDeleteFunc func(eventDao *Dao, m models.Model) error
-	AfterDeleteFunc  func(eventDao *Dao, m models.Model)
+	// write hooks
+	BeforeCreateFunc func(eventDao *Dao, m models.Model, action func() error) error
+	AfterCreateFunc  func(eventDao *Dao, m models.Model) error
+	BeforeUpdateFunc func(eventDao *Dao, m models.Model, action func() error) error
+	AfterUpdateFunc  func(eventDao *Dao, m models.Model) error
+	BeforeDeleteFunc func(eventDao *Dao, m models.Model, action func() error) error
+	AfterDeleteFunc  func(eventDao *Dao, m models.Model) error
 }
 
 // DB returns the default dao db builder (*dbx.DB or *dbx.TX).
@@ -81,6 +85,21 @@ func (dao *Dao) Clone() *Dao {
 	return &clone
 }
 
+// WithoutHooks returns a new Dao with the same configuration options
+// as the current one, but without create/update/delete hooks.
+func (dao *Dao) WithoutHooks() *Dao {
+	new := dao.Clone()
+
+	new.BeforeCreateFunc = nil
+	new.AfterCreateFunc = nil
+	new.BeforeUpdateFunc = nil
+	new.AfterUpdateFunc = nil
+	new.BeforeDeleteFunc = nil
+	new.AfterDeleteFunc = nil
+
+	return new
+}
+
 // ModelQuery creates a new preconfigured select query with preset
 // SELECT, FROM and other common fields based on the provided model.
 func (dao *Dao) ModelQuery(m models.Model) *dbx.SelectQuery {
@@ -134,56 +153,75 @@ func (dao *Dao) RunInTransaction(fn func(txDao *Dao) error) error {
 			txDao := New(tx)
 
 			if dao.BeforeCreateFunc != nil {
-				txDao.BeforeCreateFunc = func(eventDao *Dao, m models.Model) error {
-					return dao.BeforeCreateFunc(eventDao, m)
+				txDao.BeforeCreateFunc = func(eventDao *Dao, m models.Model, action func() error) error {
+					return dao.BeforeCreateFunc(eventDao, m, action)
 				}
 			}
 			if dao.BeforeUpdateFunc != nil {
-				txDao.BeforeUpdateFunc = func(eventDao *Dao, m models.Model) error {
-					return dao.BeforeUpdateFunc(eventDao, m)
+				txDao.BeforeUpdateFunc = func(eventDao *Dao, m models.Model, action func() error) error {
+					return dao.BeforeUpdateFunc(eventDao, m, action)
 				}
 			}
 			if dao.BeforeDeleteFunc != nil {
-				txDao.BeforeDeleteFunc = func(eventDao *Dao, m models.Model) error {
-					return dao.BeforeDeleteFunc(eventDao, m)
+				txDao.BeforeDeleteFunc = func(eventDao *Dao, m models.Model, action func() error) error {
+					return dao.BeforeDeleteFunc(eventDao, m, action)
 				}
 			}
 
 			if dao.AfterCreateFunc != nil {
-				txDao.AfterCreateFunc = func(eventDao *Dao, m models.Model) {
+				txDao.AfterCreateFunc = func(eventDao *Dao, m models.Model) error {
 					afterCalls = append(afterCalls, afterCallGroup{"create", eventDao, m})
+					return nil
 				}
 			}
 			if dao.AfterUpdateFunc != nil {
-				txDao.AfterUpdateFunc = func(eventDao *Dao, m models.Model) {
+				txDao.AfterUpdateFunc = func(eventDao *Dao, m models.Model) error {
 					afterCalls = append(afterCalls, afterCallGroup{"update", eventDao, m})
+					return nil
 				}
 			}
 			if dao.AfterDeleteFunc != nil {
-				txDao.AfterDeleteFunc = func(eventDao *Dao, m models.Model) {
+				txDao.AfterDeleteFunc = func(eventDao *Dao, m models.Model) error {
 					afterCalls = append(afterCalls, afterCallGroup{"delete", eventDao, m})
+					return nil
 				}
 			}
 
 			return fn(txDao)
 		})
-
-		if txError == nil {
-			// execute after event calls on successful transaction
-			// (note: using the non-transaction dao to allow following queries in the after hooks)
-			for _, call := range afterCalls {
-				switch call.Action {
-				case "create":
-					dao.AfterCreateFunc(dao, call.Model)
-				case "update":
-					dao.AfterUpdateFunc(dao, call.Model)
-				case "delete":
-					dao.AfterDeleteFunc(dao, call.Model)
-				}
-			}
+		if txError != nil {
+			return txError
 		}
 
-		return txError
+		// execute after event calls on successful transaction
+		// (note: using the non-transaction dao to allow following queries in the after hooks)
+		var errs []error
+		for _, call := range afterCalls {
+			var err error
+			switch call.Action {
+			case "create":
+				err = dao.AfterCreateFunc(dao, call.Model)
+			case "update":
+				err = dao.AfterUpdateFunc(dao, call.Model)
+			case "delete":
+				err = dao.AfterDeleteFunc(dao, call.Model)
+			}
+
+			if err != nil {
+				errs = append(errs, err)
+			}
+		}
+		if len(errs) > 0 {
+			// @todo after go 1.20+ upgrade consider replacing with errors.Join()
+			var errsMsg strings.Builder
+			for _, err := range errs {
+				errsMsg.WriteString(err.Error())
+				errsMsg.WriteString("; ")
+			}
+			return fmt.Errorf("after transaction errors: %s", errsMsg.String())
+		}
+
+		return nil
 	}
 
 	return errors.New("failed to start transaction (unknown dao.NonconcurrentDB() instance)")
@@ -196,21 +234,23 @@ func (dao *Dao) Delete(m models.Model) error {
 	}
 
 	return dao.lockRetry(func(retryDao *Dao) error {
-		if retryDao.BeforeDeleteFunc != nil {
-			if err := retryDao.BeforeDeleteFunc(retryDao, m); err != nil {
+		action := func() error {
+			if err := retryDao.NonconcurrentDB().Model(m).Delete(); err != nil {
 				return err
 			}
+
+			if retryDao.AfterDeleteFunc != nil {
+				retryDao.AfterDeleteFunc(retryDao, m)
+			}
+
+			return nil
 		}
 
-		if err := retryDao.NonconcurrentDB().Model(m).Delete(); err != nil {
-			return err
+		if retryDao.BeforeDeleteFunc != nil {
+			return retryDao.BeforeDeleteFunc(retryDao, m, action)
 		}
 
-		if retryDao.AfterDeleteFunc != nil {
-			retryDao.AfterDeleteFunc(retryDao, m)
-		}
-
-		return nil
+		return action()
 	})
 }
 
@@ -241,35 +281,35 @@ func (dao *Dao) update(m models.Model) error {
 
 	m.RefreshUpdated()
 
+	action := func() error {
+		if v, ok := any(m).(models.ColumnValueMapper); ok {
+			dataMap := v.ColumnValueMap()
+
+			_, err := dao.NonconcurrentDB().Update(
+				m.TableName(),
+				dataMap,
+				dbx.HashExp{"id": m.GetId()},
+			).Execute()
+
+			if err != nil {
+				return err
+			}
+		} else if err := dao.NonconcurrentDB().Model(m).Update(); err != nil {
+			return err
+		}
+
+		if dao.AfterUpdateFunc != nil {
+			return dao.AfterUpdateFunc(dao, m)
+		}
+
+		return nil
+	}
+
 	if dao.BeforeUpdateFunc != nil {
-		if err := dao.BeforeUpdateFunc(dao, m); err != nil {
-			return err
-		}
+		return dao.BeforeUpdateFunc(dao, m, action)
 	}
 
-	if v, ok := any(m).(models.ColumnValueMapper); ok {
-		dataMap := v.ColumnValueMap()
-
-		_, err := dao.NonconcurrentDB().Update(
-			m.TableName(),
-			dataMap,
-			dbx.HashExp{"id": m.GetId()},
-		).Execute()
-
-		if err != nil {
-			return err
-		}
-	} else {
-		if err := dao.NonconcurrentDB().Model(m).Update(); err != nil {
-			return err
-		}
-	}
-
-	if dao.AfterUpdateFunc != nil {
-		dao.AfterUpdateFunc(dao, m)
-	}
-
-	return nil
+	return action()
 }
 
 func (dao *Dao) create(m models.Model) error {
@@ -289,36 +329,36 @@ func (dao *Dao) create(m models.Model) error {
 		m.RefreshUpdated()
 	}
 
+	action := func() error {
+		if v, ok := any(m).(models.ColumnValueMapper); ok {
+			dataMap := v.ColumnValueMap()
+			if _, ok := dataMap["id"]; !ok {
+				dataMap["id"] = m.GetId()
+			}
+
+			_, err := dao.NonconcurrentDB().Insert(m.TableName(), dataMap).Execute()
+			if err != nil {
+				return err
+			}
+		} else if err := dao.NonconcurrentDB().Model(m).Insert(); err != nil {
+			return err
+		}
+
+		// clears the "new" model flag
+		m.MarkAsNotNew()
+
+		if dao.AfterCreateFunc != nil {
+			return dao.AfterCreateFunc(dao, m)
+		}
+
+		return nil
+	}
+
 	if dao.BeforeCreateFunc != nil {
-		if err := dao.BeforeCreateFunc(dao, m); err != nil {
-			return err
-		}
+		return dao.BeforeCreateFunc(dao, m, action)
 	}
 
-	if v, ok := any(m).(models.ColumnValueMapper); ok {
-		dataMap := v.ColumnValueMap()
-		if _, ok := dataMap["id"]; !ok {
-			dataMap["id"] = m.GetId()
-		}
-
-		_, err := dao.NonconcurrentDB().Insert(m.TableName(), dataMap).Execute()
-		if err != nil {
-			return err
-		}
-	} else {
-		if err := dao.NonconcurrentDB().Model(m).Insert(); err != nil {
-			return err
-		}
-	}
-
-	// clears the "new" model flag
-	m.MarkAsNotNew()
-
-	if dao.AfterCreateFunc != nil {
-		dao.AfterCreateFunc(dao, m)
-	}
-
-	return nil
+	return action()
 }
 
 func (dao *Dao) lockRetry(op func(retryDao *Dao) error) error {

daos/base_test.go

@@ -49,33 +49,37 @@ func TestDaoClone(t *testing.T) {
 	dao := daos.NewMultiDB(testApp.Dao().ConcurrentDB(), testApp.Dao().NonconcurrentDB())
 	dao.MaxLockRetries = 1
 	dao.ModelQueryTimeout = 2
-	dao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+	dao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		hookCalls["BeforeDeleteFunc"]++
-		return nil
+		return action()
 	}
-	dao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	dao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		hookCalls["BeforeUpdateFunc"]++
-		return nil
+		return action()
 	}
-	dao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	dao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		hookCalls["BeforeCreateFunc"]++
+		return action()
+	}
+	dao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+		hookCalls["AfterDeleteFunc"]++
 		return nil
 	}
-	dao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) {
-		hookCalls["AfterDeleteFunc"]++
-	}
-	dao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) {
+	dao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		hookCalls["AfterUpdateFunc"]++
+		return nil
 	}
-	dao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) {
+	dao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		hookCalls["AfterCreateFunc"]++
+		return nil
 	}
 
 	clone := dao.Clone()
 	clone.MaxLockRetries = 3
 	clone.ModelQueryTimeout = 4
-	clone.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) {
+	clone.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		hookCalls["NewAfterCreateFunc"]++
+		return nil
 	}
 
 	if dao.MaxLockRetries == clone.MaxLockRetries {
@@ -86,16 +90,18 @@ func TestDaoClone(t *testing.T) {
 		t.Fatal("Expected different ModelQueryTimeout")
 	}
 
+	emptyAction := func() error { return nil }
+
 	// trigger hooks
-	dao.BeforeDeleteFunc(nil, nil)
-	dao.BeforeUpdateFunc(nil, nil)
-	dao.BeforeCreateFunc(nil, nil)
+	dao.BeforeDeleteFunc(nil, nil, emptyAction)
+	dao.BeforeUpdateFunc(nil, nil, emptyAction)
+	dao.BeforeCreateFunc(nil, nil, emptyAction)
 	dao.AfterDeleteFunc(nil, nil)
 	dao.AfterUpdateFunc(nil, nil)
 	dao.AfterCreateFunc(nil, nil)
-	clone.BeforeDeleteFunc(nil, nil)
-	clone.BeforeUpdateFunc(nil, nil)
-	clone.BeforeCreateFunc(nil, nil)
+	clone.BeforeDeleteFunc(nil, nil, emptyAction)
+	clone.BeforeUpdateFunc(nil, nil, emptyAction)
+	clone.BeforeCreateFunc(nil, nil, emptyAction)
 	clone.AfterDeleteFunc(nil, nil)
 	clone.AfterUpdateFunc(nil, nil)
 	clone.AfterCreateFunc(nil, nil)
@@ -120,6 +126,75 @@ func TestDaoClone(t *testing.T) {
 	}
 }
 
+func TestDaoWithoutHooks(t *testing.T) {
+	testApp, _ := tests.NewTestApp()
+	defer testApp.Cleanup()
+
+	hookCalls := map[string]int{}
+
+	dao := daos.NewMultiDB(testApp.Dao().ConcurrentDB(), testApp.Dao().NonconcurrentDB())
+	dao.MaxLockRetries = 1
+	dao.ModelQueryTimeout = 2
+	dao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
+		hookCalls["BeforeDeleteFunc"]++
+		return action()
+	}
+	dao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
+		hookCalls["BeforeUpdateFunc"]++
+		return action()
+	}
+	dao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
+		hookCalls["BeforeCreateFunc"]++
+		return action()
+	}
+	dao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+		hookCalls["AfterDeleteFunc"]++
+		return nil
+	}
+	dao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+		hookCalls["AfterUpdateFunc"]++
+		return nil
+	}
+	dao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+		hookCalls["AfterCreateFunc"]++
+		return nil
+	}
+
+	new := dao.WithoutHooks()
+
+	if new.MaxLockRetries != dao.MaxLockRetries {
+		t.Fatalf("Expected MaxLockRetries %d, got %d", new.Clone().MaxLockRetries, dao.MaxLockRetries)
+	}
+
+	if new.ModelQueryTimeout != dao.ModelQueryTimeout {
+		t.Fatalf("Expected ModelQueryTimeout %d, got %d", new.Clone().ModelQueryTimeout, dao.ModelQueryTimeout)
+	}
+
+	if new.BeforeDeleteFunc != nil {
+		t.Fatal("Expected BeforeDeleteFunc to be nil")
+	}
+
+	if new.BeforeUpdateFunc != nil {
+		t.Fatal("Expected BeforeUpdateFunc to be nil")
+	}
+
+	if new.BeforeCreateFunc != nil {
+		t.Fatal("Expected BeforeCreateFunc to be nil")
+	}
+
+	if new.AfterDeleteFunc != nil {
+		t.Fatal("Expected AfterDeleteFunc to be nil")
+	}
+
+	if new.AfterUpdateFunc != nil {
+		t.Fatal("Expected AfterUpdateFunc to be nil")
+	}
+
+	if new.AfterCreateFunc != nil {
+		t.Fatal("Expected AfterCreateFunc to be nil")
+	}
+}
+
 func TestDaoModelQuery(t *testing.T) {
 	testApp, _ := tests.NewTestApp()
 	defer testApp.Cleanup()
@@ -415,12 +490,13 @@ func TestDaoRetryCreate(t *testing.T) {
 	retryBeforeCreateHookCalls := 0
 	retryAfterCreateHookCalls := 0
 	retryDao := daos.New(testApp.DB())
-	retryDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	retryDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		retryBeforeCreateHookCalls++
 		return errors.New("database is locked")
 	}
-	retryDao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) {
+	retryDao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		retryAfterCreateHookCalls++
+		return nil
 	}
 
 	model := &models.Admin{Email: "new@example.com"}
@@ -441,7 +517,7 @@ func TestDaoRetryCreate(t *testing.T) {
 	// with non-locking error
 	retryBeforeCreateHookCalls = 0
 	retryAfterCreateHookCalls = 0
-	retryDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	retryDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		retryBeforeCreateHookCalls++
 		return errors.New("non-locking error")
 	}
@@ -473,12 +549,13 @@ func TestDaoRetryUpdate(t *testing.T) {
 	retryBeforeUpdateHookCalls := 0
 	retryAfterUpdateHookCalls := 0
 	retryDao := daos.New(testApp.DB())
-	retryDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	retryDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		retryBeforeUpdateHookCalls++
 		return errors.New("database is locked")
 	}
-	retryDao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) {
+	retryDao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		retryAfterUpdateHookCalls++
+		return nil
 	}
 
 	if err := retryDao.Save(model); err != nil {
@@ -498,7 +575,7 @@ func TestDaoRetryUpdate(t *testing.T) {
 	// with non-locking error
 	retryBeforeUpdateHookCalls = 0
 	retryAfterUpdateHookCalls = 0
-	retryDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	retryDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		retryBeforeUpdateHookCalls++
 		return errors.New("non-locking error")
 	}
@@ -524,12 +601,13 @@ func TestDaoRetryDelete(t *testing.T) {
 	retryBeforeDeleteHookCalls := 0
 	retryAfterDeleteHookCalls := 0
 	retryDao := daos.New(testApp.DB())
-	retryDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+	retryDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		retryBeforeDeleteHookCalls++
 		return errors.New("database is locked")
 	}
-	retryDao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) {
+	retryDao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
 		retryAfterDeleteHookCalls++
+		return nil
 	}
 
 	model, _ := retryDao.FindAdminByEmail("test@example.com")
@@ -550,7 +628,7 @@ func TestDaoRetryDelete(t *testing.T) {
 	// with non-locking error
 	retryBeforeDeleteHookCalls = 0
 	retryAfterDeleteHookCalls = 0
-	retryDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+	retryDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		retryBeforeDeleteHookCalls++
 		return errors.New("non-locking error")
 	}
@@ -577,13 +655,13 @@ func TestDaoBeforeHooksError(t *testing.T) {
 
 	baseDao := testApp.Dao()
 
-	baseDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		return errors.New("before_create")
 	}
-	baseDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		return errors.New("before_update")
 	}
-	baseDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		return errors.New("before_delete")
 	}
 
@@ -622,27 +700,30 @@ func TestDaoTransactionHooksCallsOnFailure(t *testing.T) {
 
 	baseDao := testApp.Dao()
 
-	baseDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		beforeCreateFuncCalls++
-		return nil
+		return action()
 	}
-	baseDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		beforeUpdateFuncCalls++
-		return nil
+		return action()
 	}
-	baseDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		beforeDeleteFuncCalls++
-		return nil
+		return action()
 	}
 
-	baseDao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) {
+	baseDao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		afterCreateFuncCalls++
+		return nil
 	}
-	baseDao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) {
+	baseDao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		afterUpdateFuncCalls++
+		return nil
 	}
-	baseDao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) {
+	baseDao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
 		afterDeleteFuncCalls++
+		return nil
 	}
 
 	existingModel, _ := testApp.Dao().FindAdminByEmail("test@example.com")
@@ -710,27 +791,30 @@ func TestDaoTransactionHooksCallsOnSuccess(t *testing.T) {
 
 	baseDao := testApp.Dao()
 
-	baseDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		beforeCreateFuncCalls++
-		return nil
+		return action()
 	}
-	baseDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		beforeUpdateFuncCalls++
-		return nil
+		return action()
 	}
-	baseDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
+	baseDao.BeforeDeleteFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
 		beforeDeleteFuncCalls++
-		return nil
+		return action()
 	}
 
-	baseDao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) {
+	baseDao.AfterCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		afterCreateFuncCalls++
+		return nil
 	}
-	baseDao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) {
+	baseDao.AfterUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
 		afterUpdateFuncCalls++
+		return nil
 	}
-	baseDao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) {
+	baseDao.AfterDeleteFunc = func(eventDao *daos.Dao, m models.Model) error {
 		afterDeleteFuncCalls++
+		return nil
 	}
 
 	existingModel, _ := testApp.Dao().FindAdminByEmail("test@example.com")

daos/collection.go

@@ -378,6 +378,12 @@ func (dao *Dao) saveViewCollection(newCollection, oldCollection *models.Collecti
 			}
 		}
 
+		// wrap view query if necessary
+		query, err = txDao.normalizeViewQueryId(query)
+		if err != nil {
+			return fmt.Errorf("failed to normalize view query id: %w", err)
+		}
+
 		// (re)create the view
 		if err := txDao.SaveView(newCollection.Name, query); err != nil {
 			return err
@@ -389,6 +395,54 @@ func (dao *Dao) saveViewCollection(newCollection, oldCollection *models.Collecti
 	})
 }
 
+// @todo consider removing once custom id types are supported
+//
+// normalizeViewQueryId wraps (if necessary) the provided view query
+// with a subselect to ensure that the id column is a text since
+// currently we don't support non-string model ids
+// (see https://github.com/pocketbase/pocketbase/issues/3110).
+func (dao *Dao) normalizeViewQueryId(query string) (string, error) {
+	query = strings.Trim(strings.TrimSpace(query), ";")
+
+	parsed, err := dao.parseQueryToFields(query)
+	if err != nil {
+		return "", err
+	}
+
+	needWrapping := true
+
+	idField := parsed[schema.FieldNameId]
+	if idField != nil && idField.field != nil &&
+		idField.field.Type != schema.FieldTypeJson &&
+		idField.field.Type != schema.FieldTypeNumber &&
+		idField.field.Type != schema.FieldTypeBool {
+		needWrapping = false
+	}
+
+	if !needWrapping {
+		return query, nil // no changes needed
+	}
+
+	// raw parse to preserve the columns order
+	rawParsed := new(identifiersParser)
+	if err := rawParsed.parse(query); err != nil {
+		return "", err
+	}
+
+	columns := make([]string, 0, len(rawParsed.columns))
+	for _, col := range rawParsed.columns {
+		if col.alias == schema.FieldNameId {
+			columns = append(columns, fmt.Sprintf("cast([[%s]] as text) [[%s]]", col.alias, col.alias))
+		} else {
+			columns = append(columns, "[["+col.alias+"]]")
+		}
+	}
+
+	query = fmt.Sprintf("SELECT %s FROM (%s)", strings.Join(columns, ","), query)
+
+	return query, nil
+}
+
 // resaveViewsWithChangedSchema updates all view collections with changed schemas.
 func (dao *Dao) resaveViewsWithChangedSchema(excludeIds ...string) error {
 	collections, err := dao.FindCollectionsByType(models.CollectionTypeView)

daos/collection_test.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/models/schema"
@@ -166,9 +167,9 @@ func TestDeleteCollection(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	colEmpty := &models.Collection{}
+	colUnsaved := &models.Collection{}
 
-	colAuth, err := app.Dao().FindCollectionByNameOrId("clients")
+	colAuth, err := app.Dao().FindCollectionByNameOrId("users")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -187,6 +188,11 @@ func TestDeleteCollection(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	colBase, err := app.Dao().FindCollectionByNameOrId("demo1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	colView1, err := app.Dao().FindCollectionByNameOrId("view1")
 	if err != nil {
 		t.Fatal(err)
@@ -201,12 +207,15 @@ func TestDeleteCollection(t *testing.T) {
 		model       *models.Collection
 		expectError bool
 	}{
-		{colEmpty, true},
-		{colAuth, false},
+		{colUnsaved, true},
 		{colReferenced, true},
 		{colSystem, true},
+		{colBase, true},  // depend on view1, view2 and view2
 		{colView1, true}, // view2 depend on it
 		{colView2, false},
+		{colView1, false}, // no longer has dependent collections
+		{colBase, false},  // no longer has dependent views
+		{colAuth, false},  // should delete also its related external auths
 	}
 
 	for i, s := range scenarios {
@@ -225,6 +234,19 @@ func TestDeleteCollection(t *testing.T) {
 		if app.Dao().HasTable(s.model.Name) {
 			t.Errorf("[%d] Expected table/view %s to be deleted", i, s.model.Name)
 		}
+
+		// check if the external auths were deleted
+		if s.model.IsAuth() {
+			var total int
+			err := app.Dao().ExternalAuthQuery().
+				Select("count(*)").
+				AndWhere(dbx.HashExp{"collectionId": s.model.Id}).
+				Row(&total)
+
+			if err != nil || total > 0 {
+				t.Fatalf("[%d] Expected external auths to be deleted, got %v (%v)", i, total, err)
+			}
+		}
 	}
 }
 
@@ -372,8 +394,117 @@ func TestSaveCollectionIndirectViewsUpdate(t *testing.T) {
 	}
 }
 
+func TestSaveCollectionViewWrapping(t *testing.T) {
+	viewName := "test_wrapping"
+
+	scenarios := []struct {
+		name     string
+		query    string
+		expected string
+	}{
+		{
+			"no wrapping - text field",
+			"select text as id, bool from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select text as id, bool from demo1)",
+		},
+		{
+			"no wrapping - id field",
+			"select text as id, bool from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select text as id, bool from demo1)",
+		},
+		{
+			"no wrapping - relation field",
+			"select rel_one as id, bool from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select rel_one as id, bool from demo1)",
+		},
+		{
+			"no wrapping - select field",
+			"select select_many as id, bool from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select select_many as id, bool from demo1)",
+		},
+		{
+			"no wrapping - email field",
+			"select email as id, bool from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select email as id, bool from demo1)",
+		},
+		{
+			"no wrapping - datetime field",
+			"select datetime as id, bool from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select datetime as id, bool from demo1)",
+		},
+		{
+			"no wrapping - url field",
+			"select url as id, bool from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select url as id, bool from demo1)",
+		},
+		{
+			"wrapping - bool field",
+			"select bool as id, text as txt, url from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (SELECT cast(`id` as text) `id`,`txt`,`url` FROM (select bool as id, text as txt, url from demo1))",
+		},
+		{
+			"wrapping - bool field (different order)",
+			"select text as txt, url, bool as id from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (SELECT `txt`,`url`,cast(`id` as text) `id` FROM (select text as txt, url, bool as id from demo1))",
+		},
+		{
+			"wrapping - json field",
+			"select json as id, text, url from demo1",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (SELECT cast(`id` as text) `id`,`text`,`url` FROM (select json as id, text, url from demo1))",
+		},
+		{
+			"wrapping - numeric id",
+			"select 1 as id",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (SELECT cast(`id` as text) `id` FROM (select 1 as id))",
+		},
+		{
+			"wrapping - expresion",
+			"select ('test') as id",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (SELECT cast(`id` as text) `id` FROM (select ('test') as id))",
+		},
+		{
+			"no wrapping - cast as text",
+			"select cast('test' as text) as id",
+			"CREATE VIEW `test_wrapping` AS SELECT * FROM (select cast('test' as text) as id)",
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.name, func(t *testing.T) {
+			app, _ := tests.NewTestApp()
+			defer app.Cleanup()
+
+			collection := &models.Collection{
+				Name: viewName,
+				Type: models.CollectionTypeView,
+				Options: types.JsonMap{
+					"query": s.query,
+				},
+			}
+
+			err := app.Dao().SaveCollection(collection)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			var sql string
+
+			rowErr := app.Dao().DB().NewQuery("SELECT sql FROM sqlite_master WHERE type='view' AND name={:name}").
+				Bind(dbx.Params{"name": viewName}).
+				Row(&sql)
+			if rowErr != nil {
+				t.Fatalf("Failed to retrieve view sql: %v", rowErr)
+			}
+
+			if sql != s.expected {
+				t.Fatalf("Expected query \n%v, \ngot \n%v", s.expected, sql)
+			}
+		})
+	}
+}
+
 func TestImportCollections(t *testing.T) {
-	totalCollections := 10
+	totalCollections := 11
 
 	scenarios := []struct {
 		name                   string

daos/record.go

@@ -1,6 +1,8 @@
 package daos
 
 import (
+	"context"
+	"database/sql"
 	"errors"
 	"fmt"
 	"strings"
@@ -8,86 +10,123 @@ import (
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/models/schema"
+	"github.com/pocketbase/pocketbase/resolvers"
 	"github.com/pocketbase/pocketbase/tools/inflector"
 	"github.com/pocketbase/pocketbase/tools/list"
+	"github.com/pocketbase/pocketbase/tools/search"
 	"github.com/pocketbase/pocketbase/tools/security"
 	"github.com/pocketbase/pocketbase/tools/types"
 	"github.com/spf13/cast"
 )
 
-// RecordQuery returns a new Record select query.
-func (dao *Dao) RecordQuery(collection *models.Collection) *dbx.SelectQuery {
-	tableName := collection.Name
+// RecordQuery returns a new Record select query from a collection model, id or name.
+//
+// In case a collection id or name is provided and that collection doesn't
+// actually exists, the generated query will be created with a cancelled context
+// and will fail once an executor (Row(), One(), All(), etc.) is called.
+func (dao *Dao) RecordQuery(collectionModelOrIdentifier any) *dbx.SelectQuery {
+	var tableName string
+	var collection *models.Collection
+	var collectionErr error
+	switch c := collectionModelOrIdentifier.(type) {
+	case *models.Collection:
+		collection = c
+		tableName = collection.Name
+	case models.Collection:
+		collection = &c
+		tableName = collection.Name
+	case string:
+		collection, collectionErr = dao.FindCollectionByNameOrId(c)
+		if collection != nil {
+			tableName = collection.Name
+		} else {
+			// update with some fake table name for easier debugging
+			tableName = "@@__missing_" + c
+		}
+	default:
+		// update with some fake table name for easier debugging
+		tableName = "@@__invalidCollectionModelOrIdentifier"
+		collectionErr = errors.New("unsupported collection identifier, must be collection model, id or name")
+	}
+
 	selectCols := fmt.Sprintf("%s.*", dao.DB().QuoteSimpleColumnName(tableName))
 
-	return dao.DB().
-		Select(selectCols).
-		From(tableName).
-		WithBuildHook(func(query *dbx.Query) {
-			query.WithExecHook(execLockRetry(dao.ModelQueryTimeout, dao.MaxLockRetries)).
-				WithOneHook(func(q *dbx.Query, a any, op func(b any) error) error {
-					switch v := a.(type) {
-					case *models.Record:
-						if v == nil {
-							return op(a)
-						}
+	query := dao.DB().Select(selectCols).From(tableName)
 
-						row := dbx.NullStringMap{}
-						if err := op(&row); err != nil {
-							return err
-						}
+	// in case of an error attach a new context and cancel it immediately with the error
+	if collectionErr != nil {
+		// @todo consider changing to WithCancelCause when upgrading
+		// the min Go requirement to 1.20, so that we can pass the error
+		ctx, cancelFunc := context.WithCancel(context.Background())
+		query.WithContext(ctx)
+		cancelFunc()
+	}
 
-						record := models.NewRecordFromNullStringMap(collection, row)
-
-						*v = *record
-
-						return nil
-					default:
+	return query.WithBuildHook(func(q *dbx.Query) {
+		q.WithExecHook(execLockRetry(dao.ModelQueryTimeout, dao.MaxLockRetries)).
+			WithOneHook(func(q *dbx.Query, a any, op func(b any) error) error {
+				switch v := a.(type) {
+				case *models.Record:
+					if v == nil {
 						return op(a)
 					}
-				}).
-				WithAllHook(func(q *dbx.Query, sliceA any, op func(sliceB any) error) error {
-					switch v := sliceA.(type) {
-					case *[]*models.Record:
-						if v == nil {
-							return op(sliceA)
-						}
 
-						rows := []dbx.NullStringMap{}
-						if err := op(&rows); err != nil {
-							return err
-						}
+					row := dbx.NullStringMap{}
+					if err := op(&row); err != nil {
+						return err
+					}
 
-						records := models.NewRecordsFromNullStringMaps(collection, rows)
+					record := models.NewRecordFromNullStringMap(collection, row)
 
-						*v = records
+					*v = *record
 
-						return nil
-					case *[]models.Record:
-						if v == nil {
-							return op(sliceA)
-						}
-
-						rows := []dbx.NullStringMap{}
-						if err := op(&rows); err != nil {
-							return err
-						}
-
-						records := models.NewRecordsFromNullStringMaps(collection, rows)
-
-						nonPointers := make([]models.Record, len(records))
-						for i, r := range records {
-							nonPointers[i] = *r
-						}
-
-						*v = nonPointers
-
-						return nil
-					default:
+					return nil
+				default:
+					return op(a)
+				}
+			}).
+			WithAllHook(func(q *dbx.Query, sliceA any, op func(sliceB any) error) error {
+				switch v := sliceA.(type) {
+				case *[]*models.Record:
+					if v == nil {
 						return op(sliceA)
 					}
-				})
-		})
+
+					rows := []dbx.NullStringMap{}
+					if err := op(&rows); err != nil {
+						return err
+					}
+
+					records := models.NewRecordsFromNullStringMaps(collection, rows)
+
+					*v = records
+
+					return nil
+				case *[]models.Record:
+					if v == nil {
+						return op(sliceA)
+					}
+
+					rows := []dbx.NullStringMap{}
+					if err := op(&rows); err != nil {
+						return err
+					}
+
+					records := models.NewRecordsFromNullStringMaps(collection, rows)
+
+					nonPointers := make([]models.Record, len(records))
+					for i, r := range records {
+						nonPointers[i] = *r
+					}
+
+					*v = nonPointers
+
+					return nil
+				default:
+					return op(sliceA)
+				}
+			})
+	})
 }
 
 // FindRecordById finds the Record model by its id.
@@ -158,6 +197,8 @@ func (dao *Dao) FindRecordsByIds(
 	return records, nil
 }
 
+// @todo consider to depricate as it may be easier to just use dao.RecordQuery()
+//
 // FindRecordsByExpr finds all records by the specified db expression.
 //
 // Returns all collection records if no expressions are provided.
@@ -170,12 +211,7 @@ func (dao *Dao) FindRecordsByIds(
 //	expr2 := dbx.NewExp("LOWER(username) = {:username}", dbx.Params{"username": "test"})
 //	dao.FindRecordsByExpr("example", expr1, expr2)
 func (dao *Dao) FindRecordsByExpr(collectionNameOrId string, exprs ...dbx.Expression) ([]*models.Record, error) {
-	collection, err := dao.FindCollectionByNameOrId(collectionNameOrId)
-	if err != nil {
-		return nil, err
-	}
-
-	query := dao.RecordQuery(collection)
+	query := dao.RecordQuery(collectionNameOrId)
 
 	// add only the non-nil expressions
 	for _, expr := range exprs {
@@ -200,14 +236,9 @@ func (dao *Dao) FindFirstRecordByData(
 	key string,
 	value any,
 ) (*models.Record, error) {
-	collection, err := dao.FindCollectionByNameOrId(collectionNameOrId)
-	if err != nil {
-		return nil, err
-	}
-
 	record := &models.Record{}
 
-	err = dao.RecordQuery(collection).
+	err := dao.RecordQuery(collectionNameOrId).
 		AndWhere(dbx.HashExp{inflector.Columnify(key): value}).
 		Limit(1).
 		One(record)
@@ -218,6 +249,113 @@ func (dao *Dao) FindFirstRecordByData(
 	return record, nil
 }
 
+// FindRecordsByFilter returns limit number of records matching the
+// provided string filter.
+//
+// NB! Use the last "params" argument to bind untrusted user variables!
+//
+// The sort argument is optional and can be empty string OR the same format
+// used in the web APIs, eg. "-created,title".
+//
+// If the limit argument is <= 0, no limit is applied to the query and
+// all matching records are returned.
+//
+// Example:
+//
+//	dao.FindRecordsByFilter(
+//		"posts",
+//		"title ~ {:title} && visible = {:visible}",
+//		"-created",
+//		10,
+//		0,
+//		dbx.Params{"title": "lorem ipsum", "visible": true}
+//	)
+func (dao *Dao) FindRecordsByFilter(
+	collectionNameOrId string,
+	filter string,
+	sort string,
+	limit int,
+	offset int,
+	params ...dbx.Params,
+) ([]*models.Record, error) {
+	collection, err := dao.FindCollectionByNameOrId(collectionNameOrId)
+	if err != nil {
+		return nil, err
+	}
+
+	q := dao.RecordQuery(collection)
+
+	// build a fields resolver and attach the generated conditions to the query
+	// ---
+	resolver := resolvers.NewRecordFieldResolver(
+		dao,
+		collection, // the base collection
+		nil,        // no request data
+		true,       // allow searching hidden/protected fields like "email"
+	)
+
+	expr, err := search.FilterData(filter).BuildExpr(resolver, params...)
+	if err != nil || expr == nil {
+		return nil, errors.New("invalid or empty filter expression")
+	}
+	q.AndWhere(expr)
+
+	if sort != "" {
+		for _, sortField := range search.ParseSortFromString(sort) {
+			expr, err := sortField.BuildExpr(resolver)
+			if err != nil {
+				return nil, err
+			}
+			if expr != "" {
+				q.AndOrderBy(expr)
+			}
+		}
+	}
+
+	resolver.UpdateQuery(q) // attaches any adhoc joins and aliases
+	// ---
+
+	if offset > 0 {
+		q.Offset(int64(offset))
+	}
+
+	if limit > 0 {
+		q.Limit(int64(limit))
+	}
+
+	records := []*models.Record{}
+
+	if err := q.All(&records); err != nil {
+		return nil, err
+	}
+
+	return records, nil
+}
+
+// FindFirstRecordByFilter returns the first available record matching the provided filter.
+//
+// NB! Use the last params argument to bind untrusted user variables!
+//
+// Example:
+//
+//	dao.FindFirstRecordByFilter("posts", "slug={:slug} && status='public'", dbx.Params{"slug": "test"})
+func (dao *Dao) FindFirstRecordByFilter(
+	collectionNameOrId string,
+	filter string,
+	params ...dbx.Params,
+) (*models.Record, error) {
+	result, err := dao.FindRecordsByFilter(collectionNameOrId, filter, "", 1, 0, params...)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(result) == 0 {
+		return nil, sql.ErrNoRows
+	}
+
+	return result[0], nil
+}
+
 // IsRecordValueUnique checks if the provided key-value pair is a unique Record value.
 //
 // For correctness, if the collection is "auth" and the key is "username",
@@ -386,6 +524,62 @@ func (dao *Dao) SuggestUniqueAuthRecordUsername(
 	return username
 }
 
+// CanAccessRecord checks if a record is allowed to be accessed by the
+// specified requestInfo and accessRule.
+//
+// Rule and db checks are ignored in case requestInfo.Admin is set.
+//
+// The returned error indicate that something unexpected happened during
+// the check (eg. invalid rule or db error).
+//
+// The method always return false on invalid access rule or db error.
+//
+// Example:
+//
+//	requestInfo := apis.RequestInfo(c /* echo.Context */)
+//	record, _ := dao.FindRecordById("example", "RECORD_ID")
+//	rule := types.Pointer("@request.auth.id != '' || status = 'public'")
+//	// ... or use one of the record collection's rule, eg. record.Collection().ViewRule
+//
+//	if ok, _ := dao.CanAccessRecord(record, requestInfo, rule); ok { ... }
+func (dao *Dao) CanAccessRecord(record *models.Record, requestInfo *models.RequestInfo, accessRule *string) (bool, error) {
+	if requestInfo.Admin != nil {
+		// admins can access everything
+		return true, nil
+	}
+
+	if accessRule == nil {
+		// only admins can access this record
+		return false, nil
+	}
+
+	if *accessRule == "" {
+		// empty public rule, aka. everyone can access
+		return true, nil
+	}
+
+	var exists bool
+
+	query := dao.RecordQuery(record.Collection()).
+		Select("(1)").
+		AndWhere(dbx.HashExp{record.Collection().Name + ".id": record.Id})
+
+	// parse and apply the access rule filter
+	resolver := resolvers.NewRecordFieldResolver(dao, record.Collection(), requestInfo, true)
+	expr, err := search.FilterData(*accessRule).BuildExpr(resolver)
+	if err != nil {
+		return false, err
+	}
+	resolver.UpdateQuery(query)
+	query.AndWhere(expr)
+
+	if err := query.Limit(1).Row(&exists); err != nil && !errors.Is(err, sql.ErrNoRows) {
+		return false, err
+	}
+
+	return exists, nil
+}
+
 // SaveRecord persists the provided Record model in the database.
 //
 // If record.IsNew() is true, the method will perform a create, otherwise an update.

daos/record_expand.go

@@ -1,7 +1,6 @@
 package daos
 
 import (
-	"errors"
 	"fmt"
 	"regexp"
 	"strings"
@@ -24,21 +23,27 @@ type ExpandFetchFunc func(relCollection *models.Collection, relIds []string) ([]
 
 // ExpandRecord expands the relations of a single Record model.
 //
+// If optFetchFunc is not set, then a default function will be used
+// that returns all relation records.
+//
 // Returns a map with the failed expand parameters and their errors.
-func (dao *Dao) ExpandRecord(record *models.Record, expands []string, fetchFunc ExpandFetchFunc) map[string]error {
-	return dao.ExpandRecords([]*models.Record{record}, expands, fetchFunc)
+func (dao *Dao) ExpandRecord(record *models.Record, expands []string, optFetchFunc ExpandFetchFunc) map[string]error {
+	return dao.ExpandRecords([]*models.Record{record}, expands, optFetchFunc)
 }
 
 // ExpandRecords expands the relations of the provided Record models list.
 //
+// If optFetchFunc is not set, then a default function will be used
+// that returns all relation records.
+//
 // Returns a map with the failed expand parameters and their errors.
-func (dao *Dao) ExpandRecords(records []*models.Record, expands []string, fetchFunc ExpandFetchFunc) map[string]error {
+func (dao *Dao) ExpandRecords(records []*models.Record, expands []string, optFetchFunc ExpandFetchFunc) map[string]error {
 	normalized := normalizeExpands(expands)
 
 	failed := map[string]error{}
 
 	for _, expand := range normalized {
-		if err := dao.expandRecords(records, expand, fetchFunc, 1); err != nil {
+		if err := dao.expandRecords(records, expand, optFetchFunc, 1); err != nil {
 			failed[expand] = err
 		}
 	}
@@ -49,13 +54,16 @@ func (dao *Dao) ExpandRecords(records []*models.Record, expands []string, fetchF
 var indirectExpandRegex = regexp.MustCompile(`^(\w+)\((\w+)\)$`)
 
 // notes:
-// - fetchFunc must be non-nil func
+// - if fetchFunc is nil, dao.FindRecordsByIds will be used
 // - all records are expected to be from the same collection
 // - if MaxExpandDepth is reached, the function returns nil ignoring the remaining expand path
 // - indirect expands are supported only with single relation fields
 func (dao *Dao) expandRecords(records []*models.Record, expandPath string, fetchFunc ExpandFetchFunc, recursionLevel int) error {
 	if fetchFunc == nil {
-		return errors.New("Relation records fetchFunc is not set.")
+		// load a default fetchFunc
+		fetchFunc = func(relCollection *models.Collection, relIds []string) ([]*models.Record, error) {
+			return dao.FindRecordsByIds(relCollection.Id, relIds)
+		}
 	}
 
 	if expandPath == "" || recursionLevel > MaxExpandDepth || len(records) == 0 {

daos/record_expand_test.go

@@ -48,15 +48,6 @@ func TestExpandRecords(t *testing.T) {
 			0,
 			0,
 		},
-		{
-			"empty fetchFunc",
-			"demo4",
-			[]string{"i9naidtvr6qsgb4", "qzaqccwrmva4o1n"},
-			[]string{"self_rel_one", "self_rel_many.self_rel_one"},
-			nil,
-			0,
-			2,
-		},
 		{
 			"fetchFunc with error",
 			"demo4",
@@ -101,6 +92,19 @@ func TestExpandRecords(t *testing.T) {
 			0,
 			1,
 		},
+		{
+			"with nil fetchfunc",
+			"users",
+			[]string{
+				"bgs820n361vj1qd",
+				"4q1xlclmfloku33",
+				"oap640cot4yru2s", // no rels
+			},
+			[]string{"rel"},
+			nil,
+			2,
+			0,
+		},
 		{
 			"expand normalizations",
 			"demo4",
@@ -132,6 +136,19 @@ func TestExpandRecords(t *testing.T) {
 			2,
 			0,
 		},
+		{
+			"with nil fetchfunc",
+			"users",
+			[]string{
+				"bgs820n361vj1qd",
+				"4q1xlclmfloku33",
+				"oap640cot4yru2s", // no rels
+			},
+			[]string{"rel"},
+			nil,
+			2,
+			0,
+		},
 		{
 			"maxExpandDepth reached",
 			"demo4",
@@ -228,15 +245,6 @@ func TestExpandRecord(t *testing.T) {
 			0,
 			0,
 		},
-		{
-			"empty fetchFunc",
-			"demo4",
-			"i9naidtvr6qsgb4",
-			[]string{"self_rel_one", "self_rel_many.self_rel_one"},
-			nil,
-			0,
-			2,
-		},
 		{
 			"fetchFunc with error",
 			"demo4",

daos/record_table_sync.go

@@ -10,7 +10,6 @@ import (
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/models/schema"
 	"github.com/pocketbase/pocketbase/tools/dbutils"
-	"github.com/pocketbase/pocketbase/tools/list"
 	"github.com/pocketbase/pocketbase/tools/security"
 )
 
@@ -159,10 +158,6 @@ func (dao *Dao) SyncRecordTableSchema(newCollection *models.Collection, oldColle
 			return err
 		}
 
-		if err := txDao.syncRelationDisplayFieldsChanges(newCollection, renamedFieldNames, deletedFieldNames); err != nil {
-			return err
-		}
-
 		return txDao.createCollectionIndexes(newCollection)
 	})
 }
@@ -173,10 +168,23 @@ func (dao *Dao) normalizeSingleVsMultipleFieldChanges(newCollection, oldCollecti
 	}
 
 	return dao.RunInTransaction(func(txDao *Dao) error {
+		// temporary disable the schema error checks to prevent view and trigger errors
+		// when "altering" (aka. deleting and recreating) the non-normalized columns
+		if _, err := txDao.DB().NewQuery("PRAGMA writable_schema = ON").Execute(); err != nil {
+			return err
+		}
+		// executed with defer to make sure that the pragma is always reverted
+		// in case of an error and when nested transactions are used
+		defer txDao.DB().NewQuery("PRAGMA writable_schema = RESET").Execute()
+
 		for _, newField := range newCollection.Schema.Fields() {
-			oldField := oldCollection.Schema.GetFieldById(newField.Id)
-			if oldField == nil {
-				continue
+			// allow to continue even if there is no old field for the cases
+			// when a new field is added and there are already inserted data
+			var isOldMultiple bool
+			if oldField := oldCollection.Schema.GetFieldById(newField.Id); oldField != nil {
+				if opt, ok := oldField.Options.(schema.MultiValuer); ok {
+					isOldMultiple = opt.IsMultiple()
+				}
 			}
 
 			var isNewMultiple bool
@@ -184,20 +192,30 @@ func (dao *Dao) normalizeSingleVsMultipleFieldChanges(newCollection, oldCollecti
 				isNewMultiple = opt.IsMultiple()
 			}
 
-			var isOldMultiple bool
-			if opt, ok := oldField.Options.(schema.MultiValuer); ok {
-				isOldMultiple = opt.IsMultiple()
-			}
-
 			if isOldMultiple == isNewMultiple {
 				continue // no change
 			}
 
-			var updateQuery *dbx.Query
+			// update the column definition by:
+			// 1. inserting a new column with the new definition
+			// 2. copy normalized values from the original column to the new one
+			// 3. drop the original column
+			// 4. rename the new column to the original column
+			// -------------------------------------------------------
+
+			originalName := newField.Name
+			tempName := "_" + newField.Name + security.PseudorandomString(5)
+
+			_, err := txDao.DB().AddColumn(newCollection.Name, tempName, newField.ColDefinition()).Execute()
+			if err != nil {
+				return err
+			}
+
+			var copyQuery *dbx.Query
 
 			if !isOldMultiple && isNewMultiple {
 				// single -> multiple (convert to array)
-				updateQuery = txDao.DB().NewQuery(fmt.Sprintf(
+				copyQuery = txDao.DB().NewQuery(fmt.Sprintf(
 					`UPDATE {{%s}} set [[%s]] = (
 							CASE
 								WHEN COALESCE([[%s]], '') = ''
@@ -212,19 +230,19 @@ func (dao *Dao) normalizeSingleVsMultipleFieldChanges(newCollection, oldCollecti
 							END
 						)`,
 					newCollection.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
+					tempName,
+					originalName,
+					originalName,
+					originalName,
+					originalName,
+					originalName,
 				))
 			} else {
 				// multiple -> single (keep only the last element)
 				//
-				// note: for file fields the actual files are not deleted
-				// allowing additional custom handling via migration.
-				updateQuery = txDao.DB().NewQuery(fmt.Sprintf(
+				// note: for file fields the actual file objects are not
+				// deleted allowing additional custom handling via migration
+				copyQuery = txDao.DB().NewQuery(fmt.Sprintf(
 					`UPDATE {{%s}} set [[%s]] = (
 						CASE
 							WHEN COALESCE([[%s]], '[]') = '[]'
@@ -239,68 +257,38 @@ func (dao *Dao) normalizeSingleVsMultipleFieldChanges(newCollection, oldCollecti
 						END
 					)`,
 					newCollection.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
-					newField.Name,
+					tempName,
+					originalName,
+					originalName,
+					originalName,
+					originalName,
+					originalName,
 				))
 			}
 
-			if _, err := updateQuery.Execute(); err != nil {
+			// copy the normalized values
+			if _, err := copyQuery.Execute(); err != nil {
+				return err
+			}
+
+			// drop the original column
+			if _, err := txDao.DB().DropColumn(newCollection.Name, originalName).Execute(); err != nil {
+				return err
+			}
+
+			// rename the new column back to the original
+			if _, err := txDao.DB().RenameColumn(newCollection.Name, tempName, originalName).Execute(); err != nil {
 				return err
 			}
 		}
 
-		return nil
+		// revert the pragma and reload the schema
+		_, revertErr := txDao.DB().NewQuery("PRAGMA writable_schema = RESET").Execute()
+
+		return revertErr
 	})
 }
 
-func (dao *Dao) syncRelationDisplayFieldsChanges(collection *models.Collection, renamedFieldNames map[string]string, deletedFieldNames []string) error {
-	if len(renamedFieldNames) == 0 && len(deletedFieldNames) == 0 {
-		return nil // nothing to sync
-	}
-
-	refs, err := dao.FindCollectionReferences(collection)
-	if err != nil {
-		return err
-	}
-
-	for refCollection, refFields := range refs {
-		for _, refField := range refFields {
-			options, _ := refField.Options.(*schema.RelationOptions)
-			if options == nil {
-				continue
-			}
-
-			// remove deleted (if any)
-			newDisplayFields := list.SubtractSlice(options.DisplayFields, deletedFieldNames)
-
-			for old, new := range renamedFieldNames {
-				for i, name := range newDisplayFields {
-					if name == old {
-						newDisplayFields[i] = new
-					}
-				}
-			}
-
-			// has changes
-			if len(list.SubtractSlice(options.DisplayFields, newDisplayFields)) > 0 {
-				options.DisplayFields = newDisplayFields
-
-				// direct collection save to prevent self-referencing
-				// recursion and unnecessary records table sync checks
-				if err := dao.Save(refCollection); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
 func (dao *Dao) dropCollectionIndex(collection *models.Collection) error {
 	if collection.IsView() {
 		return nil // views don't have indexes

daos/record_table_sync_test.go

@@ -171,89 +171,149 @@ func TestSingleVsMultipleValuesNormalization(t *testing.T) {
 		opt := relManyField.Options.(*schema.RelationOptions)
 		opt.MaxSelect = types.Pointer(1)
 	}
+	{
+		// new multivaluer field to check whether the array normalization
+		// will be applied for already inserted data
+		collection.Schema.AddField(&schema.SchemaField{
+			Name: "new_multiple",
+			Type: schema.FieldTypeSelect,
+			Options: &schema.SelectOptions{
+				Values:    []string{"a", "b", "c"},
+				MaxSelect: 3,
+			},
+		})
+	}
 
 	if err := app.Dao().SaveCollection(collection); err != nil {
 		t.Fatal(err)
 	}
 
-	type expectation struct {
-		SelectOne  string `db:"select_one"`
-		SelectMany string `db:"select_many"`
-		FileOne    string `db:"file_one"`
-		FileMany   string `db:"file_many"`
-		RelOne     string `db:"rel_one"`
-		RelMany    string `db:"rel_many"`
+	// ensures that the writable schema was reverted to its expected default
+	var writableSchema bool
+	app.Dao().DB().NewQuery("PRAGMA writable_schema").Row(&writableSchema)
+	if writableSchema == true {
+		t.Fatalf("Expected writable_schema to be OFF, got %v", writableSchema)
 	}
 
-	scenarios := []struct {
+	// check whether the columns DEFAULT definition was updated
+	// ---------------------------------------------------------------
+	tableInfo, err := app.Dao().TableInfo(collection.Name)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tableInfoExpectations := map[string]string{
+		"select_one":   `'[]'`,
+		"select_many":  `''`,
+		"file_one":     `'[]'`,
+		"file_many":    `''`,
+		"rel_one":      `'[]'`,
+		"rel_many":     `''`,
+		"new_multiple": `'[]'`,
+	}
+	for col, dflt := range tableInfoExpectations {
+		t.Run("check default for "+col, func(t *testing.T) {
+			var row *models.TableInfoRow
+			for _, r := range tableInfo {
+				if r.Name == col {
+					row = r
+					break
+				}
+			}
+			if row == nil {
+				t.Fatalf("Missing info for column %q", col)
+			}
+
+			if v := row.DefaultValue.String(); v != dflt {
+				t.Fatalf("Expected default value %q, got %q", dflt, v)
+			}
+		})
+	}
+
+	// check whether the values were normalized
+	// ---------------------------------------------------------------
+	type fieldsExpectation struct {
+		SelectOne   string `db:"select_one"`
+		SelectMany  string `db:"select_many"`
+		FileOne     string `db:"file_one"`
+		FileMany    string `db:"file_many"`
+		RelOne      string `db:"rel_one"`
+		RelMany     string `db:"rel_many"`
+		NewMultiple string `db:"new_multiple"`
+	}
+
+	fieldsScenarios := []struct {
 		recordId string
-		expected expectation
+		expected fieldsExpectation
 	}{
 		{
 			"imy661ixudk5izi",
-			expectation{
-				SelectOne:  `[]`,
-				SelectMany: ``,
-				FileOne:    `[]`,
-				FileMany:   ``,
-				RelOne:     `[]`,
-				RelMany:    ``,
+			fieldsExpectation{
+				SelectOne:   `[]`,
+				SelectMany:  ``,
+				FileOne:     `[]`,
+				FileMany:    ``,
+				RelOne:      `[]`,
+				RelMany:     ``,
+				NewMultiple: `[]`,
 			},
 		},
 		{
 			"al1h9ijdeojtsjy",
-			expectation{
-				SelectOne:  `["optionB"]`,
-				SelectMany: `optionB`,
-				FileOne:    `["300_Jsjq7RdBgA.png"]`,
-				FileMany:   ``,
-				RelOne:     `["84nmscqy84lsi1t"]`,
-				RelMany:    `oap640cot4yru2s`,
+			fieldsExpectation{
+				SelectOne:   `["optionB"]`,
+				SelectMany:  `optionB`,
+				FileOne:     `["300_Jsjq7RdBgA.png"]`,
+				FileMany:    ``,
+				RelOne:      `["84nmscqy84lsi1t"]`,
+				RelMany:     `oap640cot4yru2s`,
+				NewMultiple: `[]`,
 			},
 		},
 		{
 			"84nmscqy84lsi1t",
-			expectation{
-				SelectOne:  `["optionB"]`,
-				SelectMany: `optionC`,
-				FileOne:    `["test_d61b33QdDU.txt"]`,
-				FileMany:   `test_tC1Yc87DfC.txt`,
-				RelOne:     `[]`,
-				RelMany:    `oap640cot4yru2s`,
+			fieldsExpectation{
+				SelectOne:   `["optionB"]`,
+				SelectMany:  `optionC`,
+				FileOne:     `["test_d61b33QdDU.txt"]`,
+				FileMany:    `test_tC1Yc87DfC.txt`,
+				RelOne:      `[]`,
+				RelMany:     `oap640cot4yru2s`,
+				NewMultiple: `[]`,
 			},
 		},
 	}
 
-	for _, s := range scenarios {
-		result := new(expectation)
+	for _, s := range fieldsScenarios {
+		t.Run("check fields for record "+s.recordId, func(t *testing.T) {
+			result := new(fieldsExpectation)
 
-		err := app.Dao().DB().Select(
-			"select_one",
-			"select_many",
-			"file_one",
-			"file_many",
-			"rel_one",
-			"rel_many",
-		).From(collection.Name).Where(dbx.HashExp{"id": s.recordId}).One(result)
-		if err != nil {
-			t.Errorf("[%s] Failed to load record: %v", s.recordId, err)
-			continue
-		}
+			err := app.Dao().DB().Select(
+				"select_one",
+				"select_many",
+				"file_one",
+				"file_many",
+				"rel_one",
+				"rel_many",
+				"new_multiple",
+			).From(collection.Name).Where(dbx.HashExp{"id": s.recordId}).One(result)
+			if err != nil {
+				t.Fatalf("Failed to load record: %v", err)
+			}
 
-		encodedResult, err := json.Marshal(result)
-		if err != nil {
-			t.Errorf("[%s] Failed to encode result: %v", s.recordId, err)
-			continue
-		}
+			encodedResult, err := json.Marshal(result)
+			if err != nil {
+				t.Fatalf("Failed to encode result: %v", err)
+			}
 
-		encodedExpectation, err := json.Marshal(s.expected)
-		if err != nil {
-			t.Errorf("[%s] Failed to encode expectation: %v", s.recordId, err)
-			continue
-		}
+			encodedExpectation, err := json.Marshal(s.expected)
+			if err != nil {
+				t.Fatalf("Failed to encode expectation: %v", err)
+			}
 
-		if !bytes.EqualFold(encodedExpectation, encodedResult) {
-			t.Errorf("[%s] Expected \n%s, \ngot \n%s", s.recordId, encodedExpectation, encodedResult)
-		}
+			if !bytes.EqualFold(encodedExpectation, encodedResult) {
+				t.Fatalf("Expected \n%s, \ngot \n%s", encodedExpectation, encodedResult)
+			}
+		})
 	}
 }

daos/record_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"database/sql"
 	"errors"
-	"fmt"
 	"regexp"
 	"strings"
 	"testing"
@@ -19,7 +18,7 @@ import (
 	"github.com/pocketbase/pocketbase/tools/types"
 )
 
-func TestRecordQuery(t *testing.T) {
+func TestRecordQueryWithDifferentCollectionValues(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
@@ -28,11 +27,33 @@ func TestRecordQuery(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	expected := fmt.Sprintf("SELECT `%s`.* FROM `%s`", collection.Name, collection.Name)
+	scenarios := []struct {
+		name          any
+		collection    any
+		expectedTotal int
+		expectError   bool
+	}{
+		{"with nil value", nil, 0, true},
+		{"with invalid or missing collection id/name", "missing", 0, true},
+		{"with pointer model", collection, 3, false},
+		{"with value model", *collection, 3, false},
+		{"with name", "demo1", 3, false},
+		{"with id", "wsmn24bux7wo113", 3, false},
+	}
 
-	sql := app.Dao().RecordQuery(collection).Build().SQL()
-	if sql != expected {
-		t.Errorf("Expected sql %s, got %s", expected, sql)
+	for _, s := range scenarios {
+		var records []*models.Record
+		err := app.Dao().RecordQuery(s.collection).All(&records)
+
+		hasErr := err != nil
+		if hasErr != s.expectError {
+			t.Errorf("[%s] Expected hasError %v, got %v", s.name, s.expectError, hasErr)
+			continue
+		}
+
+		if total := len(records); total != s.expectedTotal {
+			t.Errorf("[%s] Expected %d records, got %d", s.name, s.expectedTotal, total)
+		}
 	}
 }
 
@@ -405,6 +426,393 @@ func TestFindFirstRecordByData(t *testing.T) {
 	}
 }
 
+func TestFindRecordsByFilter(t *testing.T) {
+	app, _ := tests.NewTestApp()
+	defer app.Cleanup()
+
+	scenarios := []struct {
+		name               string
+		collectionIdOrName string
+		filter             string
+		sort               string
+		limit              int
+		offset             int
+		params             []dbx.Params
+		expectError        bool
+		expectRecordIds    []string
+	}{
+		{
+			"missing collection",
+			"missing",
+			"id != ''",
+			"",
+			0,
+			0,
+			nil,
+			true,
+			nil,
+		},
+		{
+			"missing filter",
+			"demo2",
+			"",
+			"",
+			0,
+			0,
+			nil,
+			true,
+			nil,
+		},
+		{
+			"invalid filter",
+			"demo2",
+			"someMissingField > 1",
+			"",
+			0,
+			0,
+			nil,
+			true,
+			nil,
+		},
+		{
+			"simple filter",
+			"demo2",
+			"id != ''",
+			"",
+			0,
+			0,
+			nil,
+			false,
+			[]string{
+				"llvuca81nly1qls",
+				"achvryl401bhse3",
+				"0yxhwia2amd8gec",
+			},
+		},
+		{
+			"multi-condition filter with sort",
+			"demo2",
+			"id != '' && active=true",
+			"-created,title",
+			-1, // should behave the same as 0
+			0,
+			nil,
+			false,
+			[]string{
+				"0yxhwia2amd8gec",
+				"achvryl401bhse3",
+			},
+		},
+		{
+			"with limit and offset",
+			"demo2",
+			"id != ''",
+			"title",
+			2,
+			1,
+			nil,
+			false,
+			[]string{
+				"achvryl401bhse3",
+				"0yxhwia2amd8gec",
+			},
+		},
+		{
+			"with placeholder params",
+			"demo2",
+			"active = {:active}",
+			"",
+			10,
+			0,
+			[]dbx.Params{{"active": false}},
+			false,
+			[]string{
+				"llvuca81nly1qls",
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.name, func(t *testing.T) {
+			records, err := app.Dao().FindRecordsByFilter(
+				s.collectionIdOrName,
+				s.filter,
+				s.sort,
+				s.limit,
+				s.offset,
+				s.params...,
+			)
+
+			hasErr := err != nil
+			if hasErr != s.expectError {
+				t.Fatalf("[%s] Expected hasErr to be %v, got %v (%v)", s.name, s.expectError, hasErr, err)
+			}
+
+			if hasErr {
+				return
+			}
+
+			if len(records) != len(s.expectRecordIds) {
+				t.Fatalf("[%s] Expected %d records, got %d", s.name, len(s.expectRecordIds), len(records))
+			}
+
+			for i, id := range s.expectRecordIds {
+				if id != records[i].Id {
+					t.Fatalf("[%s] Expected record with id %q, got %q at index %d", s.name, id, records[i].Id, i)
+				}
+			}
+		})
+	}
+}
+
+func TestFindFirstRecordByFilter(t *testing.T) {
+	app, _ := tests.NewTestApp()
+	defer app.Cleanup()
+
+	scenarios := []struct {
+		name               string
+		collectionIdOrName string
+		filter             string
+		params             []dbx.Params
+		expectError        bool
+		expectRecordId     string
+	}{
+		{
+			"missing collection",
+			"missing",
+			"id != ''",
+			nil,
+			true,
+			"",
+		},
+		{
+			"missing filter",
+			"demo2",
+			"",
+			nil,
+			true,
+			"",
+		},
+		{
+			"invalid filter",
+			"demo2",
+			"someMissingField > 1",
+			nil,
+			true,
+			"",
+		},
+		{
+			"valid filter but no matches",
+			"demo2",
+			"id = 'test'",
+			nil,
+			true,
+			"",
+		},
+		{
+			"valid filter and multiple matches",
+			"demo2",
+			"id != ''",
+			nil,
+			false,
+			"llvuca81nly1qls",
+		},
+		{
+			"with placeholder params",
+			"demo2",
+			"active = {:active}",
+			[]dbx.Params{{"active": false}},
+			false,
+			"llvuca81nly1qls",
+		},
+	}
+
+	for _, s := range scenarios {
+		record, err := app.Dao().FindFirstRecordByFilter(s.collectionIdOrName, s.filter, s.params...)
+
+		hasErr := err != nil
+		if hasErr != s.expectError {
+			t.Errorf("[%s] Expected hasErr to be %v, got %v (%v)", s.name, s.expectError, hasErr, err)
+			continue
+		}
+
+		if hasErr {
+			continue
+		}
+
+		if record.Id != s.expectRecordId {
+			t.Errorf("[%s] Expected record with id %q, got %q", s.name, s.expectRecordId, record.Id)
+		}
+	}
+}
+
+func TestCanAccessRecord(t *testing.T) {
+	app, _ := tests.NewTestApp()
+	defer app.Cleanup()
+
+	admin, err := app.Dao().FindAdminByEmail("test@example.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	authRecord, err := app.Dao().FindAuthRecordByEmail("users", "test@example.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	record, err := app.Dao().FindRecordById("demo1", "imy661ixudk5izi")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	scenarios := []struct {
+		name        string
+		record      *models.Record
+		requestInfo *models.RequestInfo
+		rule        *string
+		expected    bool
+		expectError bool
+	}{
+		{
+			"as admin with nil rule",
+			record,
+			&models.RequestInfo{
+				Admin: admin,
+			},
+			nil,
+			true,
+			false,
+		},
+		{
+			"as admin with non-empty rule",
+			record,
+			&models.RequestInfo{
+				Admin: admin,
+			},
+			types.Pointer("id = ''"), // the filter rule should be ignored
+			true,
+			false,
+		},
+		{
+			"as admin with invalid rule",
+			record,
+			&models.RequestInfo{
+				Admin: admin,
+			},
+			types.Pointer("id ?!@ 1"), // the filter rule should be ignored
+			true,
+			false,
+		},
+		{
+			"as guest with nil rule",
+			record,
+			&models.RequestInfo{},
+			nil,
+			false,
+			false,
+		},
+		{
+			"as guest with empty rule",
+			record,
+			&models.RequestInfo{},
+			types.Pointer(""),
+			true,
+			false,
+		},
+		{
+			"as guest with invalid rule",
+			record,
+			&models.RequestInfo{},
+			types.Pointer("id ?!@ 1"),
+			false,
+			true,
+		},
+		{
+			"as guest with mismatched rule",
+			record,
+			&models.RequestInfo{},
+			types.Pointer("@request.auth.id != ''"),
+			false,
+			false,
+		},
+		{
+			"as guest with matched rule",
+			record,
+			&models.RequestInfo{
+				Data: map[string]any{"test": 1},
+			},
+			types.Pointer("@request.auth.id != '' || @request.data.test = 1"),
+			true,
+			false,
+		},
+		{
+			"as auth record with nil rule",
+			record,
+			&models.RequestInfo{
+				AuthRecord: authRecord,
+			},
+			nil,
+			false,
+			false,
+		},
+		{
+			"as auth record with empty rule",
+			record,
+			&models.RequestInfo{
+				AuthRecord: authRecord,
+			},
+			types.Pointer(""),
+			true,
+			false,
+		},
+		{
+			"as auth record with invalid rule",
+			record,
+			&models.RequestInfo{
+				AuthRecord: authRecord,
+			},
+			types.Pointer("id ?!@ 1"),
+			false,
+			true,
+		},
+		{
+			"as auth record with mismatched rule",
+			record,
+			&models.RequestInfo{
+				AuthRecord: authRecord,
+				Data:       map[string]any{"test": 1},
+			},
+			types.Pointer("@request.auth.id != '' && @request.data.test > 1"),
+			false,
+			false,
+		},
+		{
+			"as auth record with matched rule",
+			record,
+			&models.RequestInfo{
+				AuthRecord: authRecord,
+				Data:       map[string]any{"test": 2},
+			},
+			types.Pointer("@request.auth.id != '' && @request.data.test > 1"),
+			true,
+			false,
+		},
+	}
+
+	for _, s := range scenarios {
+		result, err := app.Dao().CanAccessRecord(s.record, s.requestInfo, s.rule)
+
+		if result != s.expected {
+			t.Errorf("[%s] Expected %v, got %v", s.name, s.expected, result)
+		}
+
+		hasErr := err != nil
+		if hasErr != s.expectError {
+			t.Errorf("[%s] Expected hasErr %v, got %v (%v)", s.name, s.expectError, hasErr, err)
+		}
+	}
+}
+
 func TestIsRecordValueUnique(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()

daos/view.go

@@ -43,10 +43,10 @@ func (dao *Dao) SaveView(name string, selectQuery string) error {
 			return err
 		}
 
-		trimmed := strings.Trim(selectQuery, ";")
+		selectQuery = strings.Trim(strings.TrimSpace(selectQuery), ";")
 
 		// try to eagerly detect multiple inline statements
-		tk := tokenizer.NewFromString(trimmed)
+		tk := tokenizer.NewFromString(selectQuery)
 		tk.Separators(';')
 		if queryParts, _ := tk.ScanAll(); len(queryParts) > 1 {
 			return errors.New("multiple statements are not supported")
@@ -56,7 +56,7 @@ func (dao *Dao) SaveView(name string, selectQuery string) error {
 		//
 		// note: the query is wrapped in a secondary SELECT as a rudimentary
 		// measure to discourage multiple inline sql statements execution.
-		viewQuery := fmt.Sprintf("CREATE VIEW {{%s}} AS SELECT * FROM (%s)", name, trimmed)
+		viewQuery := fmt.Sprintf("CREATE VIEW {{%s}} AS SELECT * FROM (%s)", name, selectQuery)
 		if _, err := txDao.DB().NewQuery(viewQuery).Execute(); err != nil {
 			return err
 		}
@@ -127,7 +127,7 @@ func (dao *Dao) CreateViewSchema(selectQuery string) (schema.Schema, error) {
 		}
 
 		if !hasId {
-			return errors.New("missing required id column (you ca use `(ROW_NUMBER() OVER()) as id` if you don't have one)")
+			return errors.New("missing required id column (you can use `(ROW_NUMBER() OVER()) as id` if you don't have one)")
 		}
 
 		return nil
@@ -235,6 +235,8 @@ func defaultViewField(name string) *schema.SchemaField {
 	}
 }
 
+var castRegex = regexp.MustCompile(`(?i)^cast\s*\(.*\s+as\s+(\w+)\s*\)$`)
+
 func (dao *Dao) parseQueryToFields(selectQuery string) (map[string]*queryField, error) {
 	p := new(identifiersParser)
 	if err := p.parse(selectQuery); err != nil {
@@ -257,15 +259,8 @@ func (dao *Dao) parseQueryToFields(selectQuery string) (map[string]*queryField,
 	for _, col := range p.columns {
 		colLower := strings.ToLower(col.original)
 
-		// numeric expression cast
-		if strings.Contains(colLower, "(") &&
-			(strings.HasPrefix(colLower, "count(") ||
-				strings.HasPrefix(colLower, "total(") ||
-				strings.Contains(colLower, " as numeric") ||
-				strings.Contains(colLower, " as real") ||
-				strings.Contains(colLower, " as int") ||
-				strings.Contains(colLower, " as integer") ||
-				strings.Contains(colLower, " as decimal")) {
+		// numeric aggregations
+		if strings.HasPrefix(colLower, "count(") || strings.HasPrefix(colLower, "total(") {
 			result[col.alias] = &queryField{
 				field: &schema.SchemaField{
 					Name: col.alias,
@@ -275,6 +270,38 @@ func (dao *Dao) parseQueryToFields(selectQuery string) (map[string]*queryField,
 			continue
 		}
 
+		castMatch := castRegex.FindStringSubmatch(colLower)
+
+		// numeric casts
+		if len(castMatch) == 2 {
+			switch castMatch[1] {
+			case "real", "integer", "int", "decimal", "numeric":
+				result[col.alias] = &queryField{
+					field: &schema.SchemaField{
+						Name: col.alias,
+						Type: schema.FieldTypeNumber,
+					},
+				}
+				continue
+			case "text":
+				result[col.alias] = &queryField{
+					field: &schema.SchemaField{
+						Name: col.alias,
+						Type: schema.FieldTypeText,
+					},
+				}
+				continue
+			case "boolean", "bool":
+				result[col.alias] = &queryField{
+					field: &schema.SchemaField{
+						Name: col.alias,
+						Type: schema.FieldTypeBool,
+					},
+				}
+				continue
+			}
+		}
+
 		parts := strings.Split(col.original, ".")
 
 		var fieldName string
@@ -431,7 +458,7 @@ type identifiersParser struct {
 }
 
 func (p *identifiersParser) parse(selectQuery string) error {
-	str := strings.Trim(selectQuery, ";")
+	str := strings.Trim(strings.TrimSpace(selectQuery), ";")
 	str = joinReplaceRegex.ReplaceAllString(str, " _join_ ")
 	str = discardReplaceRegex.ReplaceAllString(str, " _discard_ ")
 	str = commentsReplaceRegex.ReplaceAllString(str, "")
@@ -572,13 +599,20 @@ func identifierFromParts(parts []string) (identifier, error) {
 	}
 
 	result.original = trimRawIdentifier(result.original)
-	result.alias = trimRawIdentifier(result.alias)
+
+	// we trim the single quote even though it is not a valid column quote character
+	// because SQLite allows it if the context expects an identifier and not string literal
+	// (https://www.sqlite.org/lang_keywords.html)
+	result.alias = trimRawIdentifier(result.alias, "'")
 
 	return result, nil
 }
 
-func trimRawIdentifier(rawIdentifier string) string {
-	const trimChars = "`\"[];"
+func trimRawIdentifier(rawIdentifier string, extraTrimChars ...string) string {
+	trimChars := "`\"[];"
+	if len(extraTrimChars) > 0 {
+		trimChars += strings.Join(extraTrimChars, "")
+	}
 
 	parts := strings.Split(rawIdentifier, ".")
 

daos/view_test.go

@@ -147,34 +147,33 @@ func TestSaveView(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		err := app.Dao().SaveView(s.viewName, s.query)
+		t.Run(s.scenarioName, func(t *testing.T) {
+			err := app.Dao().SaveView(s.viewName, s.query)
 
-		hasErr := err != nil
-		if hasErr != s.expectError {
-			t.Errorf("[%s] Expected hasErr %v, got %v (%v)", s.scenarioName, s.expectError, hasErr, err)
-			continue
-		}
-
-		if hasErr {
-			continue
-		}
-
-		infoRows, err := app.Dao().TableInfo(s.viewName)
-		if err != nil {
-			t.Errorf("[%s] Failed to fetch table info for %s: %v", s.scenarioName, s.viewName, err)
-			continue
-		}
-
-		if len(s.expectColumns) != len(infoRows) {
-			t.Errorf("[%s] Expected %d columns, got %d", s.scenarioName, len(s.expectColumns), len(infoRows))
-			continue
-		}
-
-		for _, row := range infoRows {
-			if !list.ExistInSlice(row.Name, s.expectColumns) {
-				t.Errorf("[%s] Missing %q column in %v", s.scenarioName, row.Name, s.expectColumns)
+			hasErr := err != nil
+			if hasErr != s.expectError {
+				t.Fatalf("Expected hasErr %v, got %v (%v)", s.expectError, hasErr, err)
 			}
-		}
+
+			if hasErr {
+				return
+			}
+
+			infoRows, err := app.Dao().TableInfo(s.viewName)
+			if err != nil {
+				t.Fatalf("Failed to fetch table info for %s: %v", s.viewName, err)
+			}
+
+			if len(s.expectColumns) != len(infoRows) {
+				t.Fatalf("Expected %d columns, got %d", len(s.expectColumns), len(infoRows))
+			}
+
+			for _, row := range infoRows {
+				if !list.ExistInSlice(row.Name, s.expectColumns) {
+					t.Fatalf("Missing %q column in %v", row.Name, s.expectColumns)
+				}
+			}
+		})
 	}
 
 	ensureNoTempViews(app, t)
@@ -272,24 +271,26 @@ func TestCreateViewSchema(t *testing.T) {
 					"datetime",
 					"json",
 					"rel_one",
-					"rel_many"
+					"rel_many",
+					'single_quoted_custom_literal' as 'single_quoted_column'
 				from demo1
 			`,
 			false,
 			map[string]string{
-				"text":         schema.FieldTypeText,
-				"bool":         schema.FieldTypeBool,
-				"url":          schema.FieldTypeUrl,
-				"select_one":   schema.FieldTypeSelect,
-				"select_many":  schema.FieldTypeSelect,
-				"file_one":     schema.FieldTypeFile,
-				"file_many":    schema.FieldTypeFile,
-				"number_alias": schema.FieldTypeNumber,
-				"email":        schema.FieldTypeEmail,
-				"datetime":     schema.FieldTypeDate,
-				"json":         schema.FieldTypeJson,
-				"rel_one":      schema.FieldTypeRelation,
-				"rel_many":     schema.FieldTypeRelation,
+				"text":                 schema.FieldTypeText,
+				"bool":                 schema.FieldTypeBool,
+				"url":                  schema.FieldTypeUrl,
+				"select_one":           schema.FieldTypeSelect,
+				"select_many":          schema.FieldTypeSelect,
+				"file_one":             schema.FieldTypeFile,
+				"file_many":            schema.FieldTypeFile,
+				"number_alias":         schema.FieldTypeNumber,
+				"email":                schema.FieldTypeEmail,
+				"datetime":             schema.FieldTypeDate,
+				"json":                 schema.FieldTypeJson,
+				"rel_one":              schema.FieldTypeRelation,
+				"rel_many":             schema.FieldTypeRelation,
+				"single_quoted_column": schema.FieldTypeJson,
 			},
 		},
 		{
@@ -330,7 +331,7 @@ func TestCreateViewSchema(t *testing.T) {
 			},
 		},
 		{
-			"query with numeric casts",
+			"query with casts",
 			`select
 				a.id,
 				count(a.id) count,
@@ -339,6 +340,9 @@ func TestCreateViewSchema(t *testing.T) {
 				cast(a.id as real) cast_real,
 				cast(a.id as decimal) cast_decimal,
 				cast(a.id as numeric) cast_numeric,
+				cast(a.id as text) cast_text,
+				cast(a.id as bool) cast_bool,
+				cast(a.id as boolean) cast_boolean,
 				avg(a.id) avg,
 				sum(a.id) sum,
 				total(a.id) total,
@@ -354,6 +358,9 @@ func TestCreateViewSchema(t *testing.T) {
 				"cast_real":    schema.FieldTypeNumber,
 				"cast_decimal": schema.FieldTypeNumber,
 				"cast_numeric": schema.FieldTypeNumber,
+				"cast_text":    schema.FieldTypeText,
+				"cast_bool":    schema.FieldTypeBool,
+				"cast_boolean": schema.FieldTypeBool,
 				// json because they are nullable
 				"sum": schema.FieldTypeJson,
 				"avg": schema.FieldTypeJson,

examples/base/main.go

@@ -22,6 +22,30 @@ func main() {
 	// Optional plugin flags:
 	// ---------------------------------------------------------------
 
+	var hooksDir string
+	app.RootCmd.PersistentFlags().StringVar(
+		&hooksDir,
+		"hooksDir",
+		"",
+		"the directory with the JS app hooks",
+	)
+
+	var hooksWatch bool
+	app.RootCmd.PersistentFlags().BoolVar(
+		&hooksWatch,
+		"hooksWatch",
+		true,
+		"auto restart the app on pb_hooks file change",
+	)
+
+	var hooksPool int
+	app.RootCmd.PersistentFlags().IntVar(
+		&hooksPool,
+		"hooksPool",
+		25,
+		"the total prewarm goja.Runtime instances for the JS app hooks execution",
+	)
+
 	var migrationsDir string
 	app.RootCmd.PersistentFlags().StringVar(
 		&migrationsDir,
@@ -68,20 +92,23 @@ func main() {
 	// Plugins and hooks:
 	// ---------------------------------------------------------------
 
-	// load js pb_migrations
-	jsvm.MustRegisterMigrations(app, &jsvm.MigrationsOptions{
-		Dir: migrationsDir,
+	// load jsvm (hooks and migrations)
+	jsvm.MustRegister(app, jsvm.Config{
+		MigrationsDir: migrationsDir,
+		HooksDir:      hooksDir,
+		HooksWatch:    hooksWatch,
+		HooksPoolSize: hooksPool,
 	})
 
 	// migrate command (with js templates)
-	migratecmd.MustRegister(app, app.RootCmd, &migratecmd.Options{
+	migratecmd.MustRegister(app, app.RootCmd, migratecmd.Config{
 		TemplateLang: migratecmd.TemplateLangJS,
 		Automigrate:  automigrate,
 		Dir:          migrationsDir,
 	})
 
 	// GitHub selfupdate
-	ghupdate.MustRegister(app, app.RootCmd, nil)
+	ghupdate.MustRegister(app, app.RootCmd, ghupdate.Config{})
 
 	app.OnAfterBootstrap().Add(func(e *core.BootstrapEvent) error {
 		app.Dao().ModelQueryTimeout = time.Duration(queryTimeout) * time.Second
@@ -105,5 +132,6 @@ func defaultPublicDir() string {
 		// most likely ran with go run
 		return "./pb_public"
 	}
+
 	return filepath.Join(os.Args[0], "../pb_public")
 }

forms/admin_password_reset_request.go

@@ -2,6 +2,7 @@ package forms
 
 import (
 	"errors"
+	"fmt"
 	"time"
 
 	validation "github.com/go-ozzo/ozzo-validation/v4"
@@ -66,7 +67,7 @@ func (form *AdminPasswordResetRequest) Submit(interceptors ...InterceptorFunc[*m
 
 	admin, err := form.dao.FindAdminByEmail(form.Email)
 	if err != nil {
-		return err
+		return fmt.Errorf("Failed to fetch admin with email %s: %w", form.Email, err)
 	}
 
 	now := time.Now().UTC()
@@ -75,14 +76,14 @@ func (form *AdminPasswordResetRequest) Submit(interceptors ...InterceptorFunc[*m
 		return errors.New("You have already requested a password reset.")
 	}
 
-	// update last sent timestamp
-	admin.LastResetSentAt = types.NowDateTime()
-
 	return runInterceptors(admin, func(m *models.Admin) error {
 		if err := mails.SendAdminPasswordReset(form.app, m); err != nil {
 			return err
 		}
 
+		// update last sent timestamp
+		m.LastResetSentAt = types.NowDateTime()
+
 		return form.dao.SaveAdmin(m)
 	}, interceptors...)
 }

forms/admin_password_reset_request_test.go

@@ -117,7 +117,7 @@ func TestAdminPasswordResetRequestInterceptors(t *testing.T) {
 		t.Fatalf("Expected interceptor2 to be called")
 	}
 
-	if interceptorLastResetSentAt.String() == admin.LastResetSentAt.String() {
-		t.Fatalf("Expected the form model to be filled before calling the interceptors")
+	if interceptorLastResetSentAt.String() != admin.LastResetSentAt.String() {
+		t.Fatalf("Expected the form model to NOT be filled before calling the interceptors")
 	}
 }

forms/backup_create_test.go

@@ -38,7 +38,7 @@ func TestBackupCreateValidateAndSubmit(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		func() {
+		t.Run(s.name, func(t *testing.T) {
 			app, _ := tests.NewTestApp()
 			defer app.Cleanup()
 
@@ -56,47 +56,47 @@ func TestBackupCreateValidateAndSubmit(t *testing.T) {
 			// parse errors
 			errs, ok := result.(validation.Errors)
 			if !ok && result != nil {
-				t.Errorf("[%s] Failed to parse errors %v", s.name, result)
+				t.Fatalf("Failed to parse errors %v", result)
 				return
 			}
 
 			// check errors
 			if len(errs) > len(s.expectedErrors) {
-				t.Errorf("[%s] Expected error keys %v, got %v", s.name, s.expectedErrors, errs)
+				t.Fatalf("Expected error keys %v, got %v", s.expectedErrors, errs)
 			}
 			for _, k := range s.expectedErrors {
 				if _, ok := errs[k]; !ok {
-					t.Errorf("[%s] Missing expected error key %q in %v", s.name, k, errs)
+					t.Fatalf("Missing expected error key %q in %v", k, errs)
 				}
 			}
 
 			// retrieve all created backup files
 			files, err := fsys.List("")
 			if err != nil {
-				t.Errorf("[%s] Failed to retrieve backup files", s.name)
+				t.Fatal("Failed to retrieve backup files")
 				return
 			}
 
 			if result != nil {
 				if total := len(files); total != 0 {
-					t.Errorf("[%s] Didn't expected backup files, found %d", s.name, total)
+					t.Fatalf("Didn't expected backup files, found %d", total)
 				}
 				return
 			}
 
 			if total := len(files); total != 1 {
-				t.Errorf("[%s] Expected 1 backup file, got %d", s.name, total)
+				t.Fatalf("Expected 1 backup file, got %d", total)
 				return
 			}
 
 			if s.backupName == "" {
 				prefix := "pb_backup_"
 				if !strings.HasPrefix(files[0].Key, prefix) {
-					t.Errorf("[%s] Expected the backup file, to have prefix %q: %q", s.name, prefix, files[0].Key)
+					t.Fatalf("Expected the backup file, to have prefix %q: %q", prefix, files[0].Key)
 				}
 			} else if s.backupName != files[0].Key {
-				t.Errorf("[%s] Expected backup file %q, got %q", s.name, s.backupName, files[0].Key)
+				t.Fatalf("Expected backup file %q, got %q", s.backupName, files[0].Key)
 			}
-		}()
+		})
 	}
 }

forms/backup_upload.go

@@ -0,0 +1,85 @@
+package forms
+
+import (
+	"context"
+
+	validation "github.com/go-ozzo/ozzo-validation/v4"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/forms/validators"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+)
+
+// BackupUpload is a request form for uploading a new app backup.
+type BackupUpload struct {
+	app core.App
+	ctx context.Context
+
+	File *filesystem.File `json:"file"`
+}
+
+// NewBackupUpload creates new BackupUpload request form.
+func NewBackupUpload(app core.App) *BackupUpload {
+	return &BackupUpload{
+		app: app,
+		ctx: context.Background(),
+	}
+}
+
+// SetContext replaces the default form upload context with the provided one.
+func (form *BackupUpload) SetContext(ctx context.Context) {
+	form.ctx = ctx
+}
+
+// Validate makes the form validatable by implementing [validation.Validatable] interface.
+func (form *BackupUpload) Validate() error {
+	return validation.ValidateStruct(form,
+		validation.Field(
+			&form.File,
+			validation.Required,
+			validation.By(validators.UploadedFileMimeType([]string{"application/zip"})),
+			validation.By(form.checkUniqueName),
+		),
+	)
+}
+
+func (form *BackupUpload) checkUniqueName(value any) error {
+	v, _ := value.(*filesystem.File)
+	if v == nil {
+		return nil // nothing to check
+	}
+
+	fsys, err := form.app.NewBackupsFilesystem()
+	if err != nil {
+		return err
+	}
+	defer fsys.Close()
+
+	fsys.SetContext(form.ctx)
+
+	if exists, err := fsys.Exists(v.OriginalName); err != nil || exists {
+		return validation.NewError("validation_backup_name_exists", "Backup file with the specified name already exists.")
+	}
+
+	return nil
+}
+
+// Submit validates the form and upload the backup file.
+//
+// You can optionally provide a list of InterceptorFunc to further
+// modify the form behavior before uploading the backup.
+func (form *BackupUpload) Submit(interceptors ...InterceptorFunc[*filesystem.File]) error {
+	if err := form.Validate(); err != nil {
+		return err
+	}
+
+	return runInterceptors(form.File, func(file *filesystem.File) error {
+		fsys, err := form.app.NewBackupsFilesystem()
+		if err != nil {
+			return err
+		}
+
+		fsys.SetContext(form.ctx)
+
+		return fsys.UploadFile(file, file.OriginalName)
+	}, interceptors...)
+}

forms/backup_upload_test.go

@@ -0,0 +1,118 @@
+package forms_test
+
+import (
+	"archive/zip"
+	"bytes"
+	"testing"
+
+	validation "github.com/go-ozzo/ozzo-validation/v4"
+	"github.com/pocketbase/pocketbase/forms"
+	"github.com/pocketbase/pocketbase/tests"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+)
+
+func TestBackupUploadValidateAndSubmit(t *testing.T) {
+	var zb bytes.Buffer
+	zw := zip.NewWriter(&zb)
+	if err := zw.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	f0, _ := filesystem.NewFileFromBytes([]byte("test"), "existing")
+	f1, _ := filesystem.NewFileFromBytes([]byte("456"), "nozip")
+	f2, _ := filesystem.NewFileFromBytes(zb.Bytes(), "existing")
+	f3, _ := filesystem.NewFileFromBytes(zb.Bytes(), "zip")
+
+	scenarios := []struct {
+		name           string
+		file           *filesystem.File
+		expectedErrors []string
+	}{
+		{
+			"missing file",
+			nil,
+			[]string{"file"},
+		},
+		{
+			"non-zip file",
+			f1,
+			[]string{"file"},
+		},
+		{
+			"zip file with non-unique name",
+			f2,
+			[]string{"file"},
+		},
+		{
+			"zip file with unique name",
+			f3,
+			[]string{},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.name, func(t *testing.T) {
+			app, _ := tests.NewTestApp()
+			defer app.Cleanup()
+
+			fsys, err := app.NewBackupsFilesystem()
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer fsys.Close()
+			// create a dummy backup file to simulate existing backups
+			if err := fsys.UploadFile(f0, f0.OriginalName); err != nil {
+				t.Fatal(err)
+			}
+
+			form := forms.NewBackupUpload(app)
+			form.File = s.file
+
+			result := form.Submit()
+
+			// parse errors
+			errs, ok := result.(validation.Errors)
+			if !ok && result != nil {
+				t.Fatalf("Failed to parse errors %v", result)
+			}
+
+			// check errors
+			if len(errs) > len(s.expectedErrors) {
+				t.Fatalf("Expected error keys %v, got %v", s.expectedErrors, errs)
+			}
+			for _, k := range s.expectedErrors {
+				if _, ok := errs[k]; !ok {
+					t.Fatalf("Missing expected error key %q in %v", k, errs)
+				}
+			}
+
+			expectedFiles := []*filesystem.File{f0}
+			if result == nil {
+				expectedFiles = append(expectedFiles, s.file)
+			}
+
+			// retrieve all uploaded backup files
+			files, err := fsys.List("")
+			if err != nil {
+				t.Fatal("Failed to retrieve backup files")
+			}
+
+			if len(files) != len(expectedFiles) {
+				t.Fatalf("Expected %d files, got %d", len(expectedFiles), len(files))
+			}
+
+			for _, ef := range expectedFiles {
+				exists := false
+				for _, f := range files {
+					if f.Key == ef.OriginalName {
+						exists = true
+						break
+					}
+				}
+				if !exists {
+					t.Fatalf("Missing expected backup file %v", ef.OriginalName)
+				}
+			}
+		})
+	}
+}

forms/collection_upsert.go

@@ -229,14 +229,6 @@ func (form *CollectionUpsert) ensureNoFieldsTypeChange(value any) error {
 func (form *CollectionUpsert) checkRelationFields(value any) error {
 	v, _ := value.(schema.Schema)
 
-	systemDisplayFields := schema.BaseModelFieldNames()
-	systemDisplayFields = append(systemDisplayFields,
-		schema.FieldNameUsername,
-		schema.FieldNameEmail,
-		schema.FieldNameEmailVisibility,
-		schema.FieldNameVerified,
-	)
-
 	for i, field := range v.Fields() {
 		if field.Type != schema.FieldTypeRelation {
 			continue
@@ -268,10 +260,10 @@ func (form *CollectionUpsert) checkRelationFields(value any) error {
 			}
 		}
 
-		collection, err := form.dao.FindCollectionByNameOrId(options.CollectionId)
+		relCollection, _ := form.dao.FindCollectionByNameOrId(options.CollectionId)
 
 		// validate collectionId
-		if err != nil || collection.Id != options.CollectionId {
+		if relCollection == nil || relCollection.Id != options.CollectionId {
 			return validation.Errors{fmt.Sprint(i): validation.Errors{
 				"options": validation.Errors{
 					"collectionId": validation.NewError(
@@ -282,17 +274,16 @@ func (form *CollectionUpsert) checkRelationFields(value any) error {
 			}
 		}
 
-		// validate displayFields (if any)
-		for _, name := range options.DisplayFields {
-			if collection.Schema.GetFieldByName(name) == nil && !list.ExistInSlice(name, systemDisplayFields) {
-				return validation.Errors{fmt.Sprint(i): validation.Errors{
-					"options": validation.Errors{
-						"displayFields": validation.NewError(
-							"validation_field_invalid_relation_displayFields",
-							fmt.Sprintf("%q does not exist in the related %q collection.", name, collection.Name),
-						),
-					}},
-				}
+		// allow only views to have relations to other views
+		// (see https://github.com/pocketbase/pocketbase/issues/3000)
+		if form.Type != models.CollectionTypeView && relCollection.IsView() {
+			return validation.Errors{fmt.Sprint(i): validation.Errors{
+				"options": validation.Errors{
+					"collectionId": validation.NewError(
+						"validation_field_non_view_base_relation_collection",
+						"Non view collections are not allowed to have a view relation.",
+					),
+				}},
 			}
 		}
 	}

forms/collection_upsert_test.go

@@ -171,25 +171,6 @@ func TestCollectionUpsertValidateAndSubmit(t *testing.T) {
 			}`,
 			[]string{"schema"},
 		},
-		{
-			"create failure - missing relation display field",
-			"",
-			`{
-				"name": "test_new",
-				"type": "base",
-				"schema": [
-					{
-						"name":"test",
-						"type":"relation",
-						"options":{
-							"collectionId":"wsmn24bux7wo113",
-							"displayFields":["text", "missing"]
-						}
-					}
-				]
-			}`,
-			[]string{"schema"},
-		},
 		{
 			"create failure - check auth options validators",
 			"",
@@ -400,6 +381,54 @@ func TestCollectionUpsertValidateAndSubmit(t *testing.T) {
 
 		// view tests
 		// -----------------------------------------------------------
+		{
+			"base->view relation",
+			"",
+			`{
+				"name": "test_view_relation",
+				"type": "base",
+				"schema": [
+					{
+						"name": "test",
+						"type": "relation",
+						"options":{
+							"collectionId": "v9gwnfh02gjq1q0"
+						}
+					}
+				]
+			}`,
+			[]string{"schema"}, // not allowed
+		},
+		{
+			"auth->view relation",
+			"",
+			`{
+				"name": "test_view_relation",
+				"type": "auth",
+				"schema": [
+					{
+						"name": "test",
+						"type": "relation",
+						"options": {
+							"collectionId": "v9gwnfh02gjq1q0"
+						}
+					}
+				]
+			}`,
+			[]string{"schema"}, // not allowed
+		},
+		{
+			"view->view relation",
+			"",
+			`{
+				"name": "test_view_relation",
+				"type": "view",
+				"options": {
+					"query": "select view1.id, view1.id as rel from view1"
+				}
+			}`,
+			[]string{}, // allowed
+		},
 		{
 			"view create failure",
 			"",
@@ -495,137 +524,132 @@ func TestCollectionUpsertValidateAndSubmit(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		collection := &models.Collection{}
-		if s.existingName != "" {
-			var err error
-			collection, err = app.Dao().FindCollectionByNameOrId(s.existingName)
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-
-		form := forms.NewCollectionUpsert(app, collection)
-
-		// load data
-		loadErr := json.Unmarshal([]byte(s.jsonData), form)
-		if loadErr != nil {
-			t.Errorf("[%s] Failed to load form data: %v", s.testName, loadErr)
-			continue
-		}
-
-		interceptorCalls := 0
-		interceptor := func(next forms.InterceptorNextFunc[*models.Collection]) forms.InterceptorNextFunc[*models.Collection] {
-			return func(c *models.Collection) error {
-				interceptorCalls++
-				return next(c)
-			}
-		}
-
-		// parse errors
-		result := form.Submit(interceptor)
-		errs, ok := result.(validation.Errors)
-		if !ok && result != nil {
-			t.Errorf("[%s] Failed to parse errors %v", s.testName, result)
-			continue
-		}
-
-		// check interceptor calls
-		expectInterceptorCalls := 1
-		if len(s.expectedErrors) > 0 {
-			expectInterceptorCalls = 0
-		}
-		if interceptorCalls != expectInterceptorCalls {
-			t.Errorf("[%s] Expected interceptor to be called %d, got %d", s.testName, expectInterceptorCalls, interceptorCalls)
-		}
-
-		// check errors
-		if len(errs) > len(s.expectedErrors) {
-			t.Errorf("[%s] Expected error keys %v, got %v", s.testName, s.expectedErrors, errs)
-		}
-		for _, k := range s.expectedErrors {
-			if _, ok := errs[k]; !ok {
-				t.Errorf("[%s] Missing expected error key %q in %v", s.testName, k, errs)
-			}
-		}
-
-		if len(s.expectedErrors) > 0 {
-			continue
-		}
-
-		collection, _ = app.Dao().FindCollectionByNameOrId(form.Name)
-		if collection == nil {
-			t.Errorf("[%s] Expected to find collection %q, got nil", s.testName, form.Name)
-			continue
-		}
-
-		if form.Name != collection.Name {
-			t.Errorf("[%s] Expected Name %q, got %q", s.testName, collection.Name, form.Name)
-		}
-
-		if form.Type != collection.Type {
-			t.Errorf("[%s] Expected Type %q, got %q", s.testName, collection.Type, form.Type)
-		}
-
-		if form.System != collection.System {
-			t.Errorf("[%s] Expected System %v, got %v", s.testName, collection.System, form.System)
-		}
-
-		if cast.ToString(form.ListRule) != cast.ToString(collection.ListRule) {
-			t.Errorf("[%s] Expected ListRule %v, got %v", s.testName, collection.ListRule, form.ListRule)
-		}
-
-		if cast.ToString(form.ViewRule) != cast.ToString(collection.ViewRule) {
-			t.Errorf("[%s] Expected ViewRule %v, got %v", s.testName, collection.ViewRule, form.ViewRule)
-		}
-
-		if cast.ToString(form.CreateRule) != cast.ToString(collection.CreateRule) {
-			t.Errorf("[%s] Expected CreateRule %v, got %v", s.testName, collection.CreateRule, form.CreateRule)
-		}
-
-		if cast.ToString(form.UpdateRule) != cast.ToString(collection.UpdateRule) {
-			t.Errorf("[%s] Expected UpdateRule %v, got %v", s.testName, collection.UpdateRule, form.UpdateRule)
-		}
-
-		if cast.ToString(form.DeleteRule) != cast.ToString(collection.DeleteRule) {
-			t.Errorf("[%s] Expected DeleteRule %v, got %v", s.testName, collection.DeleteRule, form.DeleteRule)
-		}
-
-		rawFormSchema, _ := form.Schema.MarshalJSON()
-		rawCollectionSchema, _ := collection.Schema.MarshalJSON()
-
-		if len(form.Schema.Fields()) != len(collection.Schema.Fields()) {
-			t.Errorf("[%s] Expected Schema \n%v, \ngot \n%v", s.testName, string(rawCollectionSchema), string(rawFormSchema))
-			continue
-		}
-
-		for _, f := range form.Schema.Fields() {
-			if collection.Schema.GetFieldByName(f.Name) == nil {
-				t.Errorf("[%s] Missing field %s \nin \n%v", s.testName, f.Name, string(rawFormSchema))
-				continue
-			}
-		}
-
-		// check indexes (if any)
-		allIndexes, _ := app.Dao().TableIndexes(form.Name)
-		for _, formIdx := range form.Indexes {
-			parsed := dbutils.ParseIndex(formIdx)
-			parsed.TableName = form.Name
-			normalizedIdx := parsed.Build()
-
-			var exists bool
-			for _, idx := range allIndexes {
-				if dbutils.ParseIndex(idx).Build() == normalizedIdx {
-					exists = true
-					continue
+		t.Run(s.testName, func(t *testing.T) {
+			collection := &models.Collection{}
+			if s.existingName != "" {
+				var err error
+				collection, err = app.Dao().FindCollectionByNameOrId(s.existingName)
+				if err != nil {
+					t.Fatal(err)
 				}
 			}
 
-			if !exists {
-				t.Errorf(
-					"[%s] Missing index %s \nin \n%v", s.testName, normalizedIdx, allIndexes)
-				continue
+			form := forms.NewCollectionUpsert(app, collection)
+
+			// load data
+			loadErr := json.Unmarshal([]byte(s.jsonData), form)
+			if loadErr != nil {
+				t.Fatalf("Failed to load form data: %v", loadErr)
 			}
-		}
+
+			interceptorCalls := 0
+			interceptor := func(next forms.InterceptorNextFunc[*models.Collection]) forms.InterceptorNextFunc[*models.Collection] {
+				return func(c *models.Collection) error {
+					interceptorCalls++
+					return next(c)
+				}
+			}
+
+			// parse errors
+			result := form.Submit(interceptor)
+			errs, ok := result.(validation.Errors)
+			if !ok && result != nil {
+				t.Fatalf("Failed to parse errors %v", result)
+			}
+
+			// check interceptor calls
+			expectInterceptorCalls := 1
+			if len(s.expectedErrors) > 0 {
+				expectInterceptorCalls = 0
+			}
+			if interceptorCalls != expectInterceptorCalls {
+				t.Fatalf("Expected interceptor to be called %d, got %d", expectInterceptorCalls, interceptorCalls)
+			}
+
+			// check errors
+			if len(errs) > len(s.expectedErrors) {
+				t.Fatalf("Expected error keys %v, got %v", s.expectedErrors, errs)
+			}
+			for _, k := range s.expectedErrors {
+				if _, ok := errs[k]; !ok {
+					t.Fatalf("Missing expected error key %q in %v", k, errs)
+				}
+			}
+
+			if len(s.expectedErrors) > 0 {
+				return
+			}
+
+			collection, _ = app.Dao().FindCollectionByNameOrId(form.Name)
+			if collection == nil {
+				t.Fatalf("Expected to find collection %q, got nil", form.Name)
+			}
+
+			if form.Name != collection.Name {
+				t.Fatalf("Expected Name %q, got %q", collection.Name, form.Name)
+			}
+
+			if form.Type != collection.Type {
+				t.Fatalf("Expected Type %q, got %q", collection.Type, form.Type)
+			}
+
+			if form.System != collection.System {
+				t.Fatalf("Expected System %v, got %v", collection.System, form.System)
+			}
+
+			if cast.ToString(form.ListRule) != cast.ToString(collection.ListRule) {
+				t.Fatalf("Expected ListRule %v, got %v", collection.ListRule, form.ListRule)
+			}
+
+			if cast.ToString(form.ViewRule) != cast.ToString(collection.ViewRule) {
+				t.Fatalf("Expected ViewRule %v, got %v", collection.ViewRule, form.ViewRule)
+			}
+
+			if cast.ToString(form.CreateRule) != cast.ToString(collection.CreateRule) {
+				t.Fatalf("Expected CreateRule %v, got %v", collection.CreateRule, form.CreateRule)
+			}
+
+			if cast.ToString(form.UpdateRule) != cast.ToString(collection.UpdateRule) {
+				t.Fatalf("Expected UpdateRule %v, got %v", collection.UpdateRule, form.UpdateRule)
+			}
+
+			if cast.ToString(form.DeleteRule) != cast.ToString(collection.DeleteRule) {
+				t.Fatalf("Expected DeleteRule %v, got %v", collection.DeleteRule, form.DeleteRule)
+			}
+
+			rawFormSchema, _ := form.Schema.MarshalJSON()
+			rawCollectionSchema, _ := collection.Schema.MarshalJSON()
+
+			if len(form.Schema.Fields()) != len(collection.Schema.Fields()) {
+				t.Fatalf("Expected Schema \n%v, \ngot \n%v", string(rawCollectionSchema), string(rawFormSchema))
+			}
+
+			for _, f := range form.Schema.Fields() {
+				if collection.Schema.GetFieldByName(f.Name) == nil {
+					t.Fatalf("Missing field %s \nin \n%v", f.Name, string(rawFormSchema))
+				}
+			}
+
+			// check indexes (if any)
+			allIndexes, _ := app.Dao().TableIndexes(form.Name)
+			for _, formIdx := range form.Indexes {
+				parsed := dbutils.ParseIndex(formIdx)
+				parsed.TableName = form.Name
+				normalizedIdx := parsed.Build()
+
+				var exists bool
+				for _, idx := range allIndexes {
+					if dbutils.ParseIndex(idx).Build() == normalizedIdx {
+						exists = true
+						continue
+					}
+				}
+
+				if !exists {
+					t.Fatalf("Missing index %s \nin \n%v", normalizedIdx, allIndexes)
+				}
+			}
+		})
 	}
 }
 

forms/collections_import_test.go

@@ -38,7 +38,7 @@ func TestCollectionsImportValidate(t *testing.T) {
 }
 
 func TestCollectionsImportSubmit(t *testing.T) {
-	totalCollections := 10
+	totalCollections := 11
 
 	scenarios := []struct {
 		name                   string

forms/record_oauth2_login.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	validation "github.com/go-ozzo/ozzo-validation/v4"
-	"github.com/go-ozzo/ozzo-validation/v4/is"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/models"
@@ -89,7 +88,7 @@ func (form *RecordOAuth2Login) Validate() error {
 		validation.Field(&form.Provider, validation.Required, validation.By(form.checkProviderName)),
 		validation.Field(&form.Code, validation.Required),
 		validation.Field(&form.CodeVerifier, validation.Required),
-		validation.Field(&form.RedirectUrl, validation.Required, is.URL),
+		validation.Field(&form.RedirectUrl, validation.Required),
 	)
 }
 

forms/record_oauth2_login_test.go

@@ -49,6 +49,12 @@ func TestUserOauth2LoginValidate(t *testing.T) {
 			`{"provider":"gitlab","code":"123","codeVerifier":"123","redirectUrl":"https://example.com"}`,
 			[]string{},
 		},
+		{
+			"[#3689] any redirectUrl value",
+			"users",
+			`{"provider":"gitlab","code":"123","codeVerifier":"123","redirectUrl":"something"}`,
+			[]string{},
+		},
 	}
 
 	for _, s := range scenarios {

forms/record_password_reset_request.go

@@ -2,6 +2,7 @@ package forms
 
 import (
 	"errors"
+	"fmt"
 	"time"
 
 	validation "github.com/go-ozzo/ozzo-validation/v4"
@@ -69,7 +70,7 @@ func (form *RecordPasswordResetRequest) Submit(interceptors ...InterceptorFunc[*
 
 	authRecord, err := form.dao.FindAuthRecordByEmail(form.collection.Id, form.Email)
 	if err != nil {
-		return err
+		return fmt.Errorf("Failed to fetch %s record with email %s: %w", form.collection.Id, form.Email, err)
 	}
 
 	now := time.Now().UTC()
@@ -78,14 +79,14 @@ func (form *RecordPasswordResetRequest) Submit(interceptors ...InterceptorFunc[*
 		return errors.New("You've already requested a password reset.")
 	}
 
-	// update last sent timestamp
-	authRecord.Set(schema.FieldNameLastResetSentAt, types.NowDateTime())
-
 	return runInterceptors(authRecord, func(m *models.Record) error {
 		if err := mails.SendRecordPasswordReset(form.app, m); err != nil {
 			return err
 		}
 
+		// update last sent timestamp
+		m.Set(schema.FieldNameLastResetSentAt, types.NowDateTime())
+
 		return form.dao.SaveRecord(m)
 	}, interceptors...)
 }

forms/record_password_reset_request_test.go

@@ -164,7 +164,7 @@ func TestRecordPasswordResetRequestInterceptors(t *testing.T) {
 		t.Fatalf("Expected interceptor2 to be called")
 	}
 
-	if interceptorLastResetSentAt.String() == authRecord.LastResetSentAt().String() {
-		t.Fatalf("Expected the form model to be filled before calling the interceptors")
+	if interceptorLastResetSentAt.String() != authRecord.LastResetSentAt().String() {
+		t.Fatalf("Expected the form model to NOT be filled before calling the interceptors")
 	}
 }

forms/record_upsert.go

@@ -25,7 +25,7 @@ import (
 )
 
 // username value regex pattern
-var usernameRegex = regexp.MustCompile(`^[\w][\w\.]*$`)
+var usernameRegex = regexp.MustCompile(`^[\w][\w\.\-]*$`)
 
 // RecordUpsert is a [models.Record] upsert (create/update) form.
 type RecordUpsert struct {
@@ -744,36 +744,44 @@ func (form *RecordUpsert) Submit(interceptors ...InterceptorFunc[*models.Record]
 
 		// upload new files (if any)
 		//
-		// note: executed after the default BeforeCreateFunc and BeforeUpdateFunc hooks
+		// note: executed after the default BeforeCreateFunc and BeforeUpdateFunc hook actions
 		// to allow uploading AFTER the before app model hooks (eg. in case of an id change)
 		// but BEFORE the actual record db persistence
 		// ---
-		dao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model) error {
-			if form.dao.BeforeCreateFunc != nil {
-				if err := form.dao.BeforeCreateFunc(eventDao, m); err != nil {
-					return err
+		dao.BeforeCreateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
+			newAction := func() error {
+				if m.TableName() == form.record.TableName() && m.GetId() == form.record.GetId() {
+					if err := form.processFilesToUpload(); err != nil {
+						return err
+					}
 				}
+
+				return action()
 			}
 
-			if m.TableName() == form.record.TableName() && m.GetId() == form.record.GetId() {
-				return form.processFilesToUpload()
+			if form.dao.BeforeCreateFunc != nil {
+				return form.dao.BeforeCreateFunc(eventDao, m, newAction)
 			}
 
-			return nil
+			return newAction()
 		}
 
-		dao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model) error {
-			if form.dao.BeforeUpdateFunc != nil {
-				if err := form.dao.BeforeUpdateFunc(eventDao, m); err != nil {
-					return err
+		dao.BeforeUpdateFunc = func(eventDao *daos.Dao, m models.Model, action func() error) error {
+			newAction := func() error {
+				if m.TableName() == form.record.TableName() && m.GetId() == form.record.GetId() {
+					if err := form.processFilesToUpload(); err != nil {
+						return err
+					}
 				}
+
+				return action()
 			}
 
-			if m.TableName() == form.record.TableName() && m.GetId() == form.record.GetId() {
-				return form.processFilesToUpload()
+			if form.dao.BeforeUpdateFunc != nil {
+				return form.dao.BeforeUpdateFunc(eventDao, m, newAction)
 			}
 
-			return nil
+			return newAction()
 		}
 		// ---
 
@@ -896,7 +904,7 @@ func (form *RecordUpsert) prepareError(err error) error {
 		c := form.record.Collection()
 		for _, f := range c.Schema.Fields() {
 			// blank space to unify multi-columns lookup
-			if strings.Contains(msg+" ", fmt.Sprintf("%s.%s ", strings.ToLower(c.Name), f.Name)) {
+			if strings.Contains(msg+" ", strings.ToLower(c.Name+"."+f.Name)) {
 				validationErrs[f.Name] = validation.NewError("validation_not_unique", "Value must be unique")
 			}
 		}

forms/record_upsert_test.go

@@ -12,14 +12,17 @@ import (
 	"strings"
 	"testing"
 
+	validation "github.com/go-ozzo/ozzo-validation/v4"
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/forms"
 	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/models/schema"
 	"github.com/pocketbase/pocketbase/tests"
 	"github.com/pocketbase/pocketbase/tools/filesystem"
 	"github.com/pocketbase/pocketbase/tools/list"
+	"github.com/pocketbase/pocketbase/tools/types"
 )
 
 func hasRecordFile(app core.App, record *models.Record, filename string) bool {
@@ -712,8 +715,11 @@ func TestRecordUpsertWithCustomId(t *testing.T) {
 }
 
 func TestRecordUpsertAuthRecord(t *testing.T) {
+	app, _ := tests.NewTestApp()
+	defer app.Cleanup()
+
 	scenarios := []struct {
-		testName     string
+		name         string
 		existingId   string
 		data         map[string]any
 		manageAccess bool
@@ -747,7 +753,7 @@ func TestRecordUpsertAuthRecord(t *testing.T) {
 			"create with all allowed auth fields",
 			"",
 			map[string]any{
-				"username":        "test_new",
+				"username":        "test_new-a.b",
 				"email":           "test_new@example.com",
 				"emailVisibility": true,
 				"password":        "12345678",
@@ -907,9 +913,6 @@ func TestRecordUpsertAuthRecord(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		app, _ := tests.NewTestApp()
-		defer app.Cleanup()
-
 		collection, err := app.Dao().FindCollectionByNameOrId("users")
 		if err != nil {
 			t.Fatal(err)
@@ -920,7 +923,7 @@ func TestRecordUpsertAuthRecord(t *testing.T) {
 			var err error
 			record, err = app.Dao().FindRecordById(collection.Id, s.existingId)
 			if err != nil {
-				t.Errorf("[%s] Failed to fetch auth record with id %s", s.testName, s.existingId)
+				t.Errorf("[%s] Failed to fetch auth record with id %s", s.name, s.existingId)
 				continue
 			}
 		}
@@ -928,7 +931,7 @@ func TestRecordUpsertAuthRecord(t *testing.T) {
 		form := forms.NewRecordUpsert(app, record)
 		form.SetFullManageAccess(s.manageAccess)
 		if err := form.LoadData(s.data); err != nil {
-			t.Errorf("[%s] Failed to load form data", s.testName)
+			t.Errorf("[%s] Failed to load form data", s.name)
 			continue
 		}
 
@@ -936,11 +939,119 @@ func TestRecordUpsertAuthRecord(t *testing.T) {
 
 		hasErr := submitErr != nil
 		if hasErr != s.expectError {
-			t.Errorf("[%s] Expected hasErr %v, got %v (%v)", s.testName, s.expectError, hasErr, submitErr)
+			t.Errorf("[%s] Expected hasErr %v, got %v (%v)", s.name, s.expectError, hasErr, submitErr)
 		}
 
 		if !hasErr && record.Username() == "" {
-			t.Errorf("[%s] Expected username to be set, got empty string: \n%v", s.testName, record)
+			t.Errorf("[%s] Expected username to be set, got empty string: \n%v", s.name, record)
+		}
+	}
+}
+
+func TestRecordUpsertUniqueValidator(t *testing.T) {
+	app, _ := tests.NewTestApp()
+	defer app.Cleanup()
+
+	// create a dummy collection
+	collection := &models.Collection{
+		Name: "test",
+		Schema: schema.NewSchema(
+			&schema.SchemaField{
+				Type: "text",
+				Name: "fieldA",
+			},
+			&schema.SchemaField{
+				Type: "text",
+				Name: "fieldB",
+			},
+			&schema.SchemaField{
+				Type: "text",
+				Name: "fieldC",
+			},
+		),
+		Indexes: types.JsonArray[string]{
+			// the field case shouldn't matter
+			"create unique index unique_single_idx on test (fielda)",
+			"create unique index unique_combined_idx on test (fieldb, FIELDC)",
+		},
+	}
+	if err := app.Dao().SaveCollection(collection); err != nil {
+		t.Fatal(err)
+	}
+
+	dummyRecord := models.NewRecord(collection)
+	dummyRecord.Set("fieldA", "a")
+	dummyRecord.Set("fieldB", "b")
+	dummyRecord.Set("fieldC", "c")
+	if err := app.Dao().SaveRecord(dummyRecord); err != nil {
+		t.Fatal(err)
+	}
+
+	scenarios := []struct {
+		name           string
+		data           map[string]any
+		expectedErrors []string
+	}{
+		{
+			"duplicated unique value",
+			map[string]any{
+				"fieldA": "a",
+			},
+			[]string{"fieldA"},
+		},
+		{
+			"duplicated combined unique value",
+			map[string]any{
+				"fieldB": "b",
+				"fieldC": "c",
+			},
+			[]string{"fieldB", "fieldC"},
+		},
+		{
+			"non-duplicated unique value",
+			map[string]any{
+				"fieldA": "a2",
+			},
+			nil,
+		},
+		{
+			"non-duplicated combined unique value",
+			map[string]any{
+				"fieldB": "b",
+				"fieldC": "d",
+			},
+			nil,
+		},
+	}
+
+	for _, s := range scenarios {
+		record := models.NewRecord(collection)
+
+		form := forms.NewRecordUpsert(app, record)
+		if err := form.LoadData(s.data); err != nil {
+			t.Errorf("[%s] Failed to load form data", s.name)
+			continue
+		}
+
+		result := form.Submit()
+
+		// parse errors
+		errs, ok := result.(validation.Errors)
+		if !ok && result != nil {
+			t.Errorf("[%s] Failed to parse errors %v", s.name, result)
+			continue
+		}
+
+		// check errors
+		if len(errs) > len(s.expectedErrors) {
+			t.Errorf("[%s] Expected error keys %v, got %v", s.name, s.expectedErrors, errs)
+			continue
+		}
+		for _, k := range s.expectedErrors {
+			if _, ok := errs[k]; !ok {
+				t.Errorf("[%s] Missing expected error key %q in %v", s.name, k, errs)
+				continue
+			}
 		}
 	}
 }

forms/record_verification_request.go

@@ -82,9 +82,6 @@ func (form *RecordVerificationRequest) Submit(interceptors ...InterceptorFunc[*m
 		if (now.Sub(lastVerificationSentAt)).Seconds() < form.resendThreshold {
 			return errors.New("A verification email was already sent.")
 		}
-
-		// update last sent timestamp
-		record.SetLastVerificationSentAt(types.NowDateTime())
 	}
 
 	return runInterceptors(record, func(m *models.Record) error {
@@ -96,6 +93,9 @@ func (form *RecordVerificationRequest) Submit(interceptors ...InterceptorFunc[*m
 			return err
 		}
 
+		// update last sent timestamp
+		m.SetLastVerificationSentAt(types.NowDateTime())
+
 		return form.dao.SaveRecord(m)
 	}, interceptors...)
 }

forms/record_verification_request_test.go

@@ -182,7 +182,7 @@ func TestRecordVerificationRequestInterceptors(t *testing.T) {
 		t.Fatalf("Expected interceptor2 to be called")
 	}
 
-	if interceptorLastVerificationSentAt.String() == authRecord.LastVerificationSentAt().String() {
-		t.Fatalf("Expected the form model to be filled before calling the interceptors")
+	if interceptorLastVerificationSentAt.String() != authRecord.LastVerificationSentAt().String() {
+		t.Fatalf("Expected the form model to NOT be filled before calling the interceptors")
 	}
 }

forms/settings_upsert.go

@@ -58,7 +58,7 @@ func (form *SettingsUpsert) Submit(interceptors ...InterceptorFunc[*settings.Set
 	return runInterceptors(form.Settings, func(s *settings.Settings) error {
 		form.Settings = s
 
-		oldSettings, err := form.app.Settings().Clone();
+		oldSettings, err := form.app.Settings().Clone()
 		if err != nil {
 			return err
 		}

forms/validators/record_data.go

@@ -132,11 +132,14 @@ func (validator *RecordDataValidator) checkTextValue(field *schema.SchemaField,
 
 	options, _ := field.Options.(*schema.TextOptions)
 
-	if options.Min != nil && len(val) < *options.Min {
+	// note: casted to []rune to count multi-byte chars as one
+	length := len([]rune(val))
+
+	if options.Min != nil && length < *options.Min {
 		return validation.NewError("validation_min_text_constraint", fmt.Sprintf("Must be at least %d character(s)", *options.Min))
 	}
 
-	if options.Max != nil && len(val) > *options.Max {
+	if options.Max != nil && length > *options.Max {
 		return validation.NewError("validation_max_text_constraint", fmt.Sprintf("Must be less than %d character(s)", *options.Max))
 	}
 
@@ -158,6 +161,10 @@ func (validator *RecordDataValidator) checkNumberValue(field *schema.SchemaField
 
 	options, _ := field.Options.(*schema.NumberOptions)
 
+	if options.NoDecimal && val != float64(int64(val)) {
+		return validation.NewError("validation_no_decimal_constraint", "Decimal numbers are not allowed")
+	}
+
 	if options.Min != nil && val < *options.Min {
 		return validation.NewError("validation_min_number_constraint", fmt.Sprintf("Must be larger than %f", *options.Min))
 	}

forms/validators/record_data_test.go

@@ -63,15 +63,17 @@ func TestRecordDataValidatorValidateText(t *testing.T) {
 			Name:     "field2",
 			Required: true,
 			Type:     schema.FieldTypeText,
+			Options: &schema.TextOptions{
+				Pattern: pattern,
+			},
 		},
 		&schema.SchemaField{
 			Name:   "field3",
 			Unique: true,
 			Type:   schema.FieldTypeText,
 			Options: &schema.TextOptions{
-				Min:     &min,
-				Max:     &max,
-				Pattern: pattern,
+				Min: &min,
+				Max: &max,
 			},
 		},
 	)
@@ -109,6 +111,16 @@ func TestRecordDataValidatorValidateText(t *testing.T) {
 			nil,
 			[]string{"field3"},
 		},
+		{
+			"(text) check min constraint with multi-bytes char",
+			map[string]any{
+				"field1": "test",
+				"field2": "test",
+				"field3": "𝌆", // 4 bytes should be counted as 1 char
+			},
+			nil,
+			[]string{"field3"},
+		},
 		{
 			"(text) check max constraint",
 			map[string]any{
@@ -119,15 +131,25 @@ func TestRecordDataValidatorValidateText(t *testing.T) {
 			nil,
 			[]string{"field3"},
 		},
+		{
+			"(text) check max constraint with multi-bytes chars",
+			map[string]any{
+				"field1": "test",
+				"field2": "test",
+				"field3": strings.Repeat("𝌆", max), // shouldn't exceed the max limit even though max*4bytes chars are used
+			},
+			nil,
+			[]string{},
+		},
 		{
 			"(text) check pattern constraint",
 			map[string]any{
 				"field1": nil,
-				"field2": "test",
-				"field3": "test!",
+				"field2": "test!",
+				"field3": "test",
 			},
 			nil,
-			[]string{"field3"},
+			[]string{"field2"},
 		},
 		{
 			"(text) valid data (only required)",
@@ -180,6 +202,13 @@ func TestRecordDataValidatorValidateNumber(t *testing.T) {
 				Max: &max,
 			},
 		},
+		&schema.SchemaField{
+			Name: "field4",
+			Type: schema.FieldTypeNumber,
+			Options: &schema.NumberOptions{
+				NoDecimal: true,
+			},
+		},
 	)
 	if err := app.Dao().SaveCollection(collection); err != nil {
 		t.Fatal(err)
@@ -201,6 +230,7 @@ func TestRecordDataValidatorValidateNumber(t *testing.T) {
 				"field1": nil,
 				"field2": nil,
 				"field3": nil,
+				"field4": nil,
 			},
 			nil,
 			[]string{"field2"},
@@ -211,6 +241,7 @@ func TestRecordDataValidatorValidateNumber(t *testing.T) {
 				"field1": "invalid",
 				"field2": "invalid",
 				"field3": "invalid",
+				"field4": "invalid",
 			},
 			nil,
 			[]string{"field2"},
@@ -244,6 +275,15 @@ func TestRecordDataValidatorValidateNumber(t *testing.T) {
 			nil,
 			[]string{"field3"},
 		},
+		{
+			"(number) check NoDecimal",
+			map[string]any{
+				"field2": 1,
+				"field4": 456.789,
+			},
+			nil,
+			[]string{"field4"},
+		},
 		{
 			"(number) valid data (only required)",
 			map[string]any{
@@ -258,6 +298,7 @@ func TestRecordDataValidatorValidateNumber(t *testing.T) {
 				"field1": nil,
 				"field2": 123, // test value cast
 				"field3": max,
+				"field4": 456,
 			},
 			nil,
 			[]string{},

go.mod

@@ -1,92 +1,96 @@
 module github.com/pocketbase/pocketbase
 
-go 1.18
+go 1.19
 
 require (
-	github.com/AlecAivazis/survey/v2 v2.3.6
-	github.com/aws/aws-sdk-go v1.44.266
+	github.com/AlecAivazis/survey/v2 v2.3.7
+	github.com/aws/aws-sdk-go v1.46.6
 	github.com/disintegration/imaging v1.6.2
-	github.com/domodwyer/mailyak/v3 v3.6.0
-	github.com/dop251/goja v0.0.0-20230427124612-428fc442ff5f
-	github.com/dop251/goja_nodejs v0.0.0-20230322100729-2550c7b6c124
+	github.com/domodwyer/mailyak/v3 v3.6.2
+	github.com/dop251/goja v0.0.0-20230919151941-fc55792775de
+	github.com/dop251/goja_nodejs v0.0.0-20230914102007-198ba9a8b098
 	github.com/fatih/color v1.15.0
-	github.com/gabriel-vasile/mimetype v1.4.2
+	github.com/fsnotify/fsnotify v1.6.0
+	github.com/gabriel-vasile/mimetype v1.4.3
 	github.com/ganigeorgiev/fexpr v0.3.0
 	github.com/go-ozzo/ozzo-validation/v4 v4.3.0
+	github.com/goccy/go-json v0.10.2
 	github.com/golang-jwt/jwt/v4 v4.5.0
-	github.com/labstack/echo/v5 v5.0.0-20220201181537-ed2888cfa198
-	github.com/mattn/go-sqlite3 v1.14.16
-	github.com/pocketbase/dbx v1.10.0
+	github.com/labstack/echo/v5 v5.0.0-20230722203903-ec5b858dab61
+	github.com/mattn/go-sqlite3 v1.14.17
+	github.com/pocketbase/dbx v1.10.1
+	github.com/pocketbase/tygoja v0.0.0-20231111102932-5420517293f4
 	github.com/spf13/cast v1.5.1
 	github.com/spf13/cobra v1.7.0
-	gocloud.dev v0.29.0
-	golang.org/x/crypto v0.9.0
-	golang.org/x/net v0.10.0
-	golang.org/x/oauth2 v0.8.0
-	modernc.org/sqlite v1.22.1
+	gocloud.dev v0.34.0
+	golang.org/x/crypto v0.15.0
+	golang.org/x/net v0.18.0
+	golang.org/x/oauth2 v0.13.0
+	golang.org/x/sync v0.5.0
+	modernc.org/sqlite v1.26.0
 )
 
 require (
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
-	github.com/aws/aws-sdk-go-v2 v1.18.0 // indirect
-	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 // indirect
-	github.com/aws/aws-sdk-go-v2/config v1.18.25 // indirect
-	github.com/aws/aws-sdk-go-v2/credentials v1.13.24 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.3 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.67 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.33 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.27 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/ini v1.3.34 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.25 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.28 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.27 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.2 // indirect
-	github.com/aws/aws-sdk-go-v2/service/s3 v1.33.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.12.10 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.10 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.19.0 // indirect
-	github.com/aws/smithy-go v1.13.5 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.21.2 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.14 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.19.1 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.13.43 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.13 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.92 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.43 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.37 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.3.45 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.1.6 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.15 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.38 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.37 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.15.6 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.40.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.15.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.17.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.23.2 // indirect
+	github.com/aws/smithy-go v1.15.0 // indirect
 	github.com/dlclark/regexp2 v1.10.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/google/pprof v0.0.0-20230510103437-eeec1cb781c3 // indirect
-	github.com/google/uuid v1.3.0 // indirect
+	github.com/google/pprof v0.0.0-20230912144702-c363fe2c2ed8 // indirect
+	github.com/google/uuid v1.4.0 // indirect
 	github.com/google/wire v0.5.0 // indirect
-	github.com/googleapis/gax-go/v2 v2.8.0 // indirect
+	github.com/googleapis/gax-go/v2 v2.12.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.18 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	go.opencensus.io v0.24.0 // indirect
-	golang.org/x/image v0.7.0 // indirect
-	golang.org/x/mod v0.10.0 // indirect
-	golang.org/x/sys v0.8.0 // indirect
-	golang.org/x/term v0.8.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
+	golang.org/x/image v0.13.0 // indirect
+	golang.org/x/mod v0.14.0 // indirect
+	golang.org/x/sys v0.14.0 // indirect
+	golang.org/x/term v0.14.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
-	golang.org/x/tools v0.9.1 // indirect
-	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
-	google.golang.org/api v0.123.0 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
-	google.golang.org/grpc v1.55.0 // indirect
-	google.golang.org/protobuf v1.30.0 // indirect
+	golang.org/x/tools v0.15.0 // indirect
+	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
+	google.golang.org/api v0.148.0 // indirect
+	google.golang.org/appengine v1.6.8 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20231016165738-49dd2c1f3d0b // indirect
+	google.golang.org/grpc v1.59.0 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
 	lukechampine.com/uint128 v1.3.0 // indirect
-	modernc.org/cc/v3 v3.40.0 // indirect
-	modernc.org/ccgo/v3 v3.16.13 // indirect
-	modernc.org/libc v1.22.6 // indirect
-	modernc.org/mathutil v1.5.0 // indirect
-	modernc.org/memory v1.5.0 // indirect
+	modernc.org/cc/v3 v3.41.0 // indirect
+	modernc.org/ccgo/v3 v3.16.15 // indirect
+	modernc.org/libc v1.28.0 // indirect
+	modernc.org/mathutil v1.6.0 // indirect
+	modernc.org/memory v1.7.2 // indirect
 	modernc.org/opt v0.1.3 // indirect
-	modernc.org/strutil v1.1.3 // indirect
+	modernc.org/strutil v1.2.0 // indirect
 	modernc.org/token v1.1.0 // indirect
 )

mails/admin.go

@@ -2,7 +2,6 @@ package mails
 
 import (
 	"fmt"
-	"log"
 	"net/mail"
 
 	"github.com/pocketbase/pocketbase/core"
@@ -67,15 +66,11 @@ func SendAdminPasswordReset(app core.App, admin *models.Admin) error {
 	event.Admin = admin
 	event.Meta = map[string]any{"token": token}
 
-	sendErr := app.OnMailerBeforeAdminResetPasswordSend().Trigger(event, func(e *core.MailerAdminEvent) error {
-		return e.MailClient.Send(e.Message)
-	})
-
-	if sendErr == nil {
-		if err := app.OnMailerAfterAdminResetPasswordSend().Trigger(event); err != nil && app.IsDebug() {
-			log.Println(err)
+	return app.OnMailerBeforeAdminResetPasswordSend().Trigger(event, func(e *core.MailerAdminEvent) error {
+		if err := e.MailClient.Send(e.Message); err != nil {
+			return err
 		}
-	}
 
-	return sendErr
+		return app.OnMailerAfterAdminResetPasswordSend().Trigger(e)
+	})
 }

mails/record.go

@@ -2,7 +2,6 @@ package mails
 
 import (
 	"html/template"
-	"log"
 	"net/mail"
 
 	"github.com/pocketbase/pocketbase/core"
@@ -44,17 +43,13 @@ func SendRecordPasswordReset(app core.App, authRecord *models.Record) error {
 	event.Record = authRecord
 	event.Meta = map[string]any{"token": token}
 
-	sendErr := app.OnMailerBeforeRecordResetPasswordSend().Trigger(event, func(e *core.MailerRecordEvent) error {
-		return e.MailClient.Send(e.Message)
-	})
-
-	if sendErr == nil {
-		if err := app.OnMailerAfterRecordResetPasswordSend().Trigger(event); err != nil && app.IsDebug() {
-			log.Println(err)
+	return app.OnMailerBeforeRecordResetPasswordSend().Trigger(event, func(e *core.MailerRecordEvent) error {
+		if err := e.MailClient.Send(e.Message); err != nil {
+			return err
 		}
-	}
 
-	return sendErr
+		return app.OnMailerAfterRecordResetPasswordSend().Trigger(e)
+	})
 }
 
 // SendRecordVerification sends a verification request email to the specified user.
@@ -88,17 +83,13 @@ func SendRecordVerification(app core.App, authRecord *models.Record) error {
 	event.Record = authRecord
 	event.Meta = map[string]any{"token": token}
 
-	sendErr := app.OnMailerBeforeRecordVerificationSend().Trigger(event, func(e *core.MailerRecordEvent) error {
-		return e.MailClient.Send(e.Message)
-	})
-
-	if sendErr == nil {
-		if err := app.OnMailerAfterRecordVerificationSend().Trigger(event); err != nil && app.IsDebug() {
-			log.Println(err)
+	return app.OnMailerBeforeRecordVerificationSend().Trigger(event, func(e *core.MailerRecordEvent) error {
+		if err := e.MailClient.Send(e.Message); err != nil {
+			return err
 		}
-	}
 
-	return sendErr
+		return app.OnMailerAfterRecordVerificationSend().Trigger(e)
+	})
 }
 
 // SendUserChangeEmail sends a change email confirmation email to the specified user.
@@ -135,17 +126,13 @@ func SendRecordChangeEmail(app core.App, record *models.Record, newEmail string)
 		"newEmail": newEmail,
 	}
 
-	sendErr := app.OnMailerBeforeRecordChangeEmailSend().Trigger(event, func(e *core.MailerRecordEvent) error {
-		return e.MailClient.Send(e.Message)
-	})
-
-	if sendErr == nil {
-		if err := app.OnMailerAfterRecordChangeEmailSend().Trigger(event); err != nil && app.IsDebug() {
-			log.Println(err)
+	return app.OnMailerBeforeRecordChangeEmailSend().Trigger(event, func(e *core.MailerRecordEvent) error {
+		if err := e.MailClient.Send(e.Message); err != nil {
+			return err
 		}
-	}
 
-	return sendErr
+		return app.OnMailerAfterRecordChangeEmailSend().Trigger(e)
+	})
 }
 
 func resolveEmailTemplate(

migrations/1640988000_init.go

@@ -100,7 +100,7 @@ func init() {
 			return err
 		}
 
-		// inserts the system profiles collection
+		// inserts the system users collection
 		// -----------------------------------------------------------
 		usersCollection := &models.Collection{}
 		usersCollection.MarkAsNew()

migrations/1679943780_normalize_single_multiple_values.go

@@ -12,93 +12,97 @@ import (
 // Normalizes old single and multiple values of MultiValuer fields (file, select, relation).
 func init() {
 	AppMigrations.Register(func(db dbx.Builder) error {
-		dao := daos.New(db)
-
-		collections := []*models.Collection{}
-		if err := dao.CollectionQuery().All(&collections); err != nil {
-			return err
-		}
-
-		for _, c := range collections {
-			if c.IsView() {
-				// skip view collections
-				continue
-			}
-
-			for _, f := range c.Schema.Fields() {
-				opt, ok := f.Options.(schema.MultiValuer)
-				if !ok {
-					continue
-				}
-
-				var updateQuery *dbx.Query
-
-				if opt.IsMultiple() {
-					updateQuery = dao.DB().NewQuery(fmt.Sprintf(
-						`UPDATE {{%s}} set [[%s]] = (
-							CASE
-								WHEN COALESCE([[%s]], '') = ''
-								THEN '[]'
-								ELSE (
-									CASE
-										WHEN json_valid([[%s]]) AND json_type([[%s]]) == 'array'
-										THEN [[%s]]
-										ELSE json_array([[%s]])
-									END
-								)
-							END
-						)`,
-						c.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-					))
-				} else {
-					updateQuery = dao.DB().NewQuery(fmt.Sprintf(
-						`UPDATE {{%s}} set [[%s]] = (
-							CASE
-								WHEN COALESCE([[%s]], '[]') = '[]'
-								THEN ''
-								ELSE (
-									CASE
-										WHEN json_valid([[%s]]) AND json_type([[%s]]) == 'array'
-										THEN COALESCE(json_extract([[%s]], '$[#-1]'), '')
-										ELSE [[%s]]
-									END
-								)
-							END
-						)`,
-						c.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-						f.Name,
-					))
-				}
-
-				if _, err := updateQuery.Execute(); err != nil {
-					return err
-				}
-			}
-		}
-
-		// trigger view query update after the records normalization
-		// (ignore save error in case of invalid query to allow users to change it from the UI)
-		for _, c := range collections {
-			if !c.IsView() {
-				continue
-			}
-
-			dao.SaveCollection(c)
-		}
-
-		return nil
+		return normalizeMultivaluerFields(db)
 	}, func(db dbx.Builder) error {
 		return nil
 	})
 }
+
+func normalizeMultivaluerFields(db dbx.Builder) error {
+	dao := daos.New(db)
+
+	collections := []*models.Collection{}
+	if err := dao.CollectionQuery().All(&collections); err != nil {
+		return err
+	}
+
+	for _, c := range collections {
+		if c.IsView() {
+			// skip view collections
+			continue
+		}
+
+		for _, f := range c.Schema.Fields() {
+			opt, ok := f.Options.(schema.MultiValuer)
+			if !ok {
+				continue
+			}
+
+			var updateQuery *dbx.Query
+
+			if opt.IsMultiple() {
+				updateQuery = dao.DB().NewQuery(fmt.Sprintf(
+					`UPDATE {{%s}} set [[%s]] = (
+						CASE
+							WHEN COALESCE([[%s]], '') = ''
+							THEN '[]'
+							ELSE (
+								CASE
+									WHEN json_valid([[%s]]) AND json_type([[%s]]) == 'array'
+									THEN [[%s]]
+									ELSE json_array([[%s]])
+								END
+							)
+						END
+					)`,
+					c.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+				))
+			} else {
+				updateQuery = dao.DB().NewQuery(fmt.Sprintf(
+					`UPDATE {{%s}} set [[%s]] = (
+						CASE
+							WHEN COALESCE([[%s]], '[]') = '[]'
+							THEN ''
+							ELSE (
+								CASE
+									WHEN json_valid([[%s]]) AND json_type([[%s]]) == 'array'
+									THEN COALESCE(json_extract([[%s]], '$[#-1]'), '')
+									ELSE [[%s]]
+								END
+							)
+						END
+					)`,
+					c.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+					f.Name,
+				))
+			}
+
+			if _, err := updateQuery.Execute(); err != nil {
+				return err
+			}
+		}
+	}
+
+	// trigger view query update after the records normalization
+	// (ignore save error in case of invalid query to allow users to change it from the UI)
+	for _, c := range collections {
+		if !c.IsView() {
+			continue
+		}
+
+		dao.SaveCollection(c)
+	}
+
+	return nil
+}

migrations/1685164450_check_fk.go

@@ -0,0 +1,20 @@
+package migrations
+
+import (
+	"github.com/pocketbase/dbx"
+)
+
+// Cleanup dangling deleted collections references
+// (see https://github.com/pocketbase/pocketbase/discussions/2570).
+func init() {
+	AppMigrations.Register(func(db dbx.Builder) error {
+		_, err := db.NewQuery(`
+			DELETE FROM {{_externalAuths}}
+			WHERE [[collectionId]] NOT IN (SELECT [[id]] FROM {{_collections}})
+		`).Execute()
+
+		return err
+	}, func(db dbx.Builder) error {
+		return nil
+	})
+}

migrations/1689579878_renormalize_single_multiple_values.go

@@ -0,0 +1,15 @@
+package migrations
+
+import (
+	"github.com/pocketbase/dbx"
+)
+
+// Renormalizes old single and multiple values of MultiValuer fields (file, select, relation)
+// (see https://github.com/pocketbase/pocketbase/issues/2930).
+func init() {
+	AppMigrations.Register(func(db dbx.Builder) error {
+		return normalizeMultivaluerFields(db)
+	}, func(db dbx.Builder) error {
+		return nil
+	})
+}

migrations/1690319366_reset_null_values.go

@@ -0,0 +1,58 @@
+package migrations
+
+import (
+	"fmt"
+
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/models/schema"
+)
+
+// Reset all previously inserted NULL values to the fields zero-default.
+func init() {
+	AppMigrations.Register(func(db dbx.Builder) error {
+		dao := daos.New(db)
+
+		collections := []*models.Collection{}
+		if err := dao.CollectionQuery().All(&collections); err != nil {
+			return err
+		}
+
+		for _, collection := range collections {
+			if collection.IsView() {
+				continue
+			}
+
+			for _, f := range collection.Schema.Fields() {
+				defaultVal := "''"
+
+				switch f.Type {
+				case schema.FieldTypeJson:
+					continue
+				case schema.FieldTypeBool:
+					defaultVal = "FALSE"
+				case schema.FieldTypeNumber:
+					defaultVal = "0"
+				default:
+					if opt, ok := f.Options.(schema.MultiValuer); ok && opt.IsMultiple() {
+						defaultVal = "'[]'"
+					}
+				}
+
+				_, err := db.NewQuery(fmt.Sprintf(
+					"UPDATE {{%s}} SET [[%s]] = %s WHERE [[%s]] IS NULL",
+					collection.Name,
+					f.Name,
+					defaultVal,
+					f.Name,
+				)).Execute()
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	}, nil)
+}

migrations/1690454337_transform_relations_to_views.go

@@ -0,0 +1,61 @@
+package migrations
+
+import (
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/models/schema"
+)
+
+// Transform the relation fields to views from non-view collections to json or text fields
+// (see https://github.com/pocketbase/pocketbase/issues/3000).
+func init() {
+	AppMigrations.Register(func(db dbx.Builder) error {
+		dao := daos.New(db)
+
+		views, err := dao.FindCollectionsByType(models.CollectionTypeView)
+		if err != nil {
+			return err
+		}
+
+		for _, view := range views {
+			refs, err := dao.FindCollectionReferences(view)
+			if err != nil {
+				return nil
+			}
+
+			for collection, fields := range refs {
+				if collection.IsView() {
+					continue // view-view relations are allowed
+				}
+
+				for _, f := range fields {
+					opt, ok := f.Options.(schema.MultiValuer)
+					if !ok {
+						continue
+					}
+
+					if opt.IsMultiple() {
+						f.Type = schema.FieldTypeJson
+						f.Options = &schema.JsonOptions{}
+					} else {
+						f.Type = schema.FieldTypeText
+						f.Options = &schema.TextOptions{}
+					}
+
+					// replace the existing field
+					// (this usually is not necessary since it is a pointer,
+					// but it is better to be explicit in case FindCollectionReferences changes)
+					collection.Schema.AddField(f)
+				}
+
+				// "raw" save without records table sync
+				if err := dao.Save(collection); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	}, nil)
+}

migrations/1691747913_resave_views.go

@@ -0,0 +1,28 @@
+package migrations
+
+import (
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/models"
+)
+
+// Resave all view collections to ensure that the proper id normalization is applied.
+// (see https://github.com/pocketbase/pocketbase/issues/3110)
+func init() {
+	AppMigrations.Register(func(db dbx.Builder) error {
+		dao := daos.New(db)
+
+		collections, err := dao.FindCollectionsByType(models.CollectionTypeView)
+		if err != nil {
+			return nil
+		}
+
+		for _, collection := range collections {
+			// ignore errors to allow users to adjust
+			// the view queries after app start
+			dao.SaveCollection(collection)
+		}
+
+		return nil
+	}, nil)
+}

migrations/1692609521_copy_display_fields.go

@@ -0,0 +1,62 @@
+package migrations
+
+import (
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/models/schema"
+)
+
+// Copy the now deprecated RelationOptions.DisplayFields values from
+// all relation fields and register its value as Presentable under
+// the specific field in the related collection.
+//
+// If there is more than one relation to a single collection with explicitly
+// set DisplayFields only one of the configuration will be copied.
+func init() {
+	AppMigrations.Register(func(db dbx.Builder) error {
+		dao := daos.New(db)
+
+		collections := []*models.Collection{}
+		if err := dao.CollectionQuery().All(&collections); err != nil {
+			return err
+		}
+
+		indexedCollections := make(map[string]*models.Collection, len(collections))
+		for _, collection := range collections {
+			indexedCollections[collection.Id] = collection
+		}
+
+		for _, collection := range indexedCollections {
+			for _, f := range collection.Schema.Fields() {
+				if f.Type != schema.FieldTypeRelation {
+					continue
+				}
+
+				options, ok := f.Options.(*schema.RelationOptions)
+				if !ok || len(options.DisplayFields) == 0 {
+					continue
+				}
+
+				relCollection, ok := indexedCollections[options.CollectionId]
+				if !ok {
+					continue
+				}
+
+				for _, name := range options.DisplayFields {
+					relField := relCollection.Schema.GetFieldByName(name)
+					if relField != nil {
+						relField.Presentable = true
+					}
+				}
+
+				// only raw model save
+				if err := dao.Save(relCollection); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	}, nil)
+}

models/record.go

@@ -324,7 +324,7 @@ func (m *Record) Set(key string, value any) {
 	}
 }
 
-// Get returns a single record model data value for "key".
+// Get returns a normalized single record model data value for "key".
 func (m *Record) Get(key string) any {
 	switch key {
 	case schema.FieldNameId:
@@ -334,11 +334,27 @@ func (m *Record) Get(key string) any {
 	case schema.FieldNameUpdated:
 		return m.Updated
 	default:
-		if m.data == nil {
-			return nil
+		var v any
+		if m.data != nil {
+			v = m.data.Get(key)
 		}
 
-		return m.data.Get(key)
+		// normalize the field value in case it is missing or an incorrect type was set
+		// to ensure that the DB will always have normalized columns value.
+		if field := m.Collection().Schema.GetFieldByName(key); field != nil {
+			v = field.PrepareValue(v)
+		} else if m.collection.IsAuth() {
+			switch key {
+			case schema.FieldNameEmailVisibility, schema.FieldNameVerified:
+				v = cast.ToBool(v)
+			case schema.FieldNameLastResetSentAt, schema.FieldNameLastVerificationSentAt:
+				v, _ = types.ParseDateTime(v)
+			case schema.FieldNameUsername, schema.FieldNameEmail, schema.FieldNameTokenKey, schema.FieldNamePasswordHash:
+				v = cast.ToString(v)
+			}
+		}
+
+		return v
 	}
 }
 
@@ -378,6 +394,56 @@ func (m *Record) GetStringSlice(key string) []string {
 	return list.ToUniqueStringSlice(m.Get(key))
 }
 
+// ExpandedOne retrieves a single relation Record from the already
+// loaded expand data of the current model.
+//
+// If the requested expand relation is multiple, this method returns
+// only first available Record from the expanded relation.
+//
+// Returns nil if there is no such expand relation loaded.
+func (m *Record) ExpandedOne(relField string) *Record {
+	if m.expand == nil {
+		return nil
+	}
+
+	rel := m.expand.Get(relField)
+
+	switch v := rel.(type) {
+	case *Record:
+		return v
+	case []*Record:
+		if len(v) > 0 {
+			return v[0]
+		}
+	}
+
+	return nil
+}
+
+// ExpandedAll retrieves a slice of relation Records from the already
+// loaded expand data of the current model.
+//
+// If the requested expand relation is single, this method normalizes
+// the return result and will wrap the single model as a slice.
+//
+// Returns nil slice if there is no such expand relation loaded.
+func (m *Record) ExpandedAll(relField string) []*Record {
+	if m.expand == nil {
+		return nil
+	}
+
+	rel := m.expand.Get(relField)
+
+	switch v := rel.(type) {
+	case *Record:
+		return []*Record{v}
+	case []*Record:
+		return v
+	}
+
+	return nil
+}
+
 // Retrieves the "key" json field value and unmarshals it into "result".
 //
 // Example
@@ -447,7 +513,8 @@ func (m *Record) ColumnValueMap() map[string]any {
 
 // PublicExport exports only the record fields that are safe to be public.
 //
-// Fields marked as hidden will be exported only if `m.IgnoreEmailVisibility(true)` is set.
+// For auth records, to force the export of the email field you need to set
+// `m.IgnoreEmailVisibility(true)`.
 func (m *Record) PublicExport() map[string]any {
 	result := make(map[string]any, len(m.collection.Schema.Fields())+5)
 

models/record_test.go

@@ -541,6 +541,70 @@ func TestRecordMergeExpandNilCheck(t *testing.T) {
 	}
 }
 
+func TestRecordExpandedRel(t *testing.T) {
+	collection := &models.Collection{}
+
+	main := models.NewRecord(collection)
+
+	single := models.NewRecord(collection)
+	single.Id = "single"
+
+	multiple1 := models.NewRecord(collection)
+	multiple1.Id = "multiple1"
+
+	multiple2 := models.NewRecord(collection)
+	multiple2.Id = "multiple2"
+
+	main.SetExpand(map[string]any{
+		"single":   single,
+		"multiple": []*models.Record{multiple1, multiple2},
+	})
+
+	if v := main.ExpandedOne("missing"); v != nil {
+		t.Fatalf("Expected nil, got %v", v)
+	}
+
+	if v := main.ExpandedOne("single"); v == nil || v.Id != "single" {
+		t.Fatalf("Expected record with id %q, got %v", "single", v)
+	}
+
+	if v := main.ExpandedOne("multiple"); v == nil || v.Id != "multiple1" {
+		t.Fatalf("Expected record with id %q, got %v", "multiple1", v)
+	}
+}
+
+func TestRecordExpandedAll(t *testing.T) {
+	collection := &models.Collection{}
+
+	main := models.NewRecord(collection)
+
+	single := models.NewRecord(collection)
+	single.Id = "single"
+
+	multiple1 := models.NewRecord(collection)
+	multiple1.Id = "multiple1"
+
+	multiple2 := models.NewRecord(collection)
+	multiple2.Id = "multiple2"
+
+	main.SetExpand(map[string]any{
+		"single":   single,
+		"multiple": []*models.Record{multiple1, multiple2},
+	})
+
+	if v := main.ExpandedAll("missing"); v != nil {
+		t.Fatalf("Expected nil, got %v", v)
+	}
+
+	if v := main.ExpandedAll("single"); len(v) != 1 || v[0].Id != "single" {
+		t.Fatalf("Expected [single] slice, got %v", v)
+	}
+
+	if v := main.ExpandedAll("multiple"); len(v) != 2 || v[0].Id != "multiple1" || v[1].Id != "multiple2" {
+		t.Fatalf("Expected [multiple1, multiple2] slice, got %v", v)
+	}
+}
+
 func TestRecordSchemaData(t *testing.T) {
 	collection := &models.Collection{
 		Type: models.CollectionTypeAuth,
@@ -665,6 +729,22 @@ func TestRecordSetAndGet(t *testing.T) {
 				Name: "field2",
 				Type: schema.FieldTypeNumber,
 			},
+			// fields that are not explicitly set to check
+			// the default retrieval value (single and multiple)
+			&schema.SchemaField{
+				Name: "field3",
+				Type: schema.FieldTypeBool,
+			},
+			&schema.SchemaField{
+				Name:    "field4",
+				Type:    schema.FieldTypeSelect,
+				Options: &schema.SelectOptions{MaxSelect: 2},
+			},
+			&schema.SchemaField{
+				Name:    "field5",
+				Type:    schema.FieldTypeRelation,
+				Options: &schema.RelationOptions{MaxSelect: types.Pointer(1)},
+			},
 		),
 	}
 
@@ -677,28 +757,40 @@ func TestRecordSetAndGet(t *testing.T) {
 	m.Set("unknown", 456)                        // undefined fields are allowed but not exported by default
 	m.Set("expand", map[string]any{"test": 123}) // should store the value in m.expand
 
-	if m.Get("id") != "test_id" {
-		t.Fatalf("Expected id %q, got %q", "test_id", m.Get("id"))
+	if v := m.Get("id"); v != "test_id" {
+		t.Fatalf("Expected id %q, got %q", "test_id", v)
 	}
 
-	if m.GetString("created") != "2022-09-15 00:00:00.123Z" {
-		t.Fatalf("Expected created %q, got %q", "2022-09-15 00:00:00.123Z", m.GetString("created"))
+	if v := m.GetString("created"); v != "2022-09-15 00:00:00.123Z" {
+		t.Fatalf("Expected created %q, got %q", "2022-09-15 00:00:00.123Z", v)
 	}
 
-	if m.GetString("updated") != "" {
-		t.Fatalf("Expected updated to be empty, got %q", m.GetString("updated"))
+	if v := m.GetString("updated"); v != "" {
+		t.Fatalf("Expected updated to be empty, got %q", v)
 	}
 
-	if m.Get("field1") != "123" {
-		t.Fatalf("Expected field1 %q, got %v", "123", m.Get("field1"))
+	if v, ok := m.Get("field1").(string); !ok || v != "123" {
+		t.Fatalf("Expected field1 %#v, got %#v", "123", m.Get("field1"))
 	}
 
-	if m.Get("field2") != 0.0 {
-		t.Fatalf("Expected field2 %v, got %v", 0.0, m.Get("field2"))
+	if v, ok := m.Get("field2").(float64); !ok || v != 0.0 {
+		t.Fatalf("Expected field2 %#v, got %#v", 0.0, m.Get("field2"))
 	}
 
-	if m.Get("unknown") != 456 {
-		t.Fatalf("Expected unknown %v, got %v", 456, m.Get("unknown"))
+	if v, ok := m.Get("field3").(bool); !ok || v != false {
+		t.Fatalf("Expected field3 %#v, got %#v", false, m.Get("field3"))
+	}
+
+	if v, ok := m.Get("field4").([]string); !ok || len(v) != 0 {
+		t.Fatalf("Expected field4 %#v, got %#v", "[]", m.Get("field4"))
+	}
+
+	if v, ok := m.Get("field5").(string); !ok || len(v) != 0 {
+		t.Fatalf("Expected field5 %#v, got %#v", "", m.Get("field5"))
+	}
+
+	if v := m.Get("unknown"); v != 456 {
+		t.Fatalf("Expected unknown %v, got %v", 456, v)
 	}
 
 	if m.Expand()["test"] != 123 {

models/request_info.go

@@ -6,19 +6,19 @@ import (
 	"github.com/pocketbase/pocketbase/models/schema"
 )
 
-// RequestData defines a HTTP request data struct, usually used
+// RequestInfo defines a HTTP request data struct, usually used
 // as part of the `@request.*` filter resolver.
-type RequestData struct {
-	Method     string         `json:"method"`
+type RequestInfo struct {
 	Query      map[string]any `json:"query"`
 	Data       map[string]any `json:"data"`
 	Headers    map[string]any `json:"headers"`
 	AuthRecord *Record        `json:"authRecord"`
 	Admin      *Admin         `json:"admin"`
+	Method     string         `json:"method"`
 }
 
 // HasModifierDataKeys loosely checks if the current struct has any modifier Data keys.
-func (r *RequestData) HasModifierDataKeys() bool {
+func (r *RequestInfo) HasModifierDataKeys() bool {
 	allModifiers := schema.FieldValueModifiers()
 
 	for key := range r.Data {

models/request_info_test.go

@@ -6,20 +6,20 @@ import (
 	"github.com/pocketbase/pocketbase/models"
 )
 
-func TestRequestDataHasModifierDataKeys(t *testing.T) {
+func TestRequestInfoHasModifierDataKeys(t *testing.T) {
 	scenarios := []struct {
 		name        string
-		requestData *models.RequestData
+		requestInfo *models.RequestInfo
 		expected    bool
 	}{
 		{
 			"empty",
-			&models.RequestData{},
+			&models.RequestInfo{},
 			false,
 		},
 		{
 			"Data with regular fields",
-			&models.RequestData{
+			&models.RequestInfo{
 				Query: map[string]any{"data+": "demo"}, // should be ignored
 				Data:  map[string]any{"a": 123, "b": "test", "c.d": false},
 			},
@@ -27,21 +27,21 @@ func TestRequestDataHasModifierDataKeys(t *testing.T) {
 		},
 		{
 			"Data with +modifier fields",
-			&models.RequestData{
+			&models.RequestInfo{
 				Data: map[string]any{"a+": 123, "b": "test", "c.d": false},
 			},
 			true,
 		},
 		{
 			"Data with -modifier fields",
-			&models.RequestData{
+			&models.RequestInfo{
 				Data: map[string]any{"a": 123, "b-": "test", "c.d": false},
 			},
 			true,
 		},
 		{
 			"Data with mixed modifier fields",
-			&models.RequestData{
+			&models.RequestInfo{
 				Data: map[string]any{"a": 123, "b-": "test", "c.d+": false},
 			},
 			true,
@@ -49,7 +49,7 @@ func TestRequestDataHasModifierDataKeys(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		result := s.requestData.HasModifierDataKeys()
+		result := s.requestInfo.HasModifierDataKeys()
 
 		if result != s.expected {
 			t.Fatalf("[%s] Expected %v, got %v", s.name, s.expected, result)

models/schema/schema_field.go

@@ -132,6 +132,10 @@ type SchemaField struct {
 	Type     string `form:"type" json:"type"`
 	Required bool   `form:"required" json:"required"`
 
+	// Presentable indicates whether the field is suitable for
+	// visualization purposes (eg. in the Admin UI relation views).
+	Presentable bool `form:"presentable" json:"presentable"`
+
 	// Deprecated: This field is no-op and will be removed in future versions.
 	// Please use the collection.Indexes field to define a unique constraint.
 	Unique bool `form:"unique" json:"unique"`
@@ -143,13 +147,17 @@ type SchemaField struct {
 func (f *SchemaField) ColDefinition() string {
 	switch f.Type {
 	case FieldTypeNumber:
-		return "NUMERIC DEFAULT 0"
+		return "NUMERIC DEFAULT 0 NOT NULL"
 	case FieldTypeBool:
-		return "BOOLEAN DEFAULT FALSE"
+		return "BOOLEAN DEFAULT FALSE NOT NULL"
 	case FieldTypeJson:
 		return "JSON DEFAULT NULL"
 	default:
-		return "TEXT DEFAULT ''"
+		if opt, ok := f.Options.(MultiValuer); ok && opt.IsMultiple() {
+			return "JSON DEFAULT '[]' NOT NULL"
+		}
+
+		return "TEXT DEFAULT '' NOT NULL"
 	}
 }
 
@@ -190,7 +198,7 @@ func (f SchemaField) Validate() error {
 
 	excludeNames := BaseModelFieldNames()
 	// exclude special filter literals
-	excludeNames = append(excludeNames, "null", "true", "false")
+	excludeNames = append(excludeNames, "null", "true", "false", "_rowid_")
 	// exclude system literals
 	excludeNames = append(excludeNames, SystemFieldNames()...)
 
@@ -448,21 +456,36 @@ func (o *TextOptions) checkRegex(value any) error {
 // -------------------------------------------------------------------
 
 type NumberOptions struct {
-	Min *float64 `form:"min" json:"min"`
-	Max *float64 `form:"max" json:"max"`
+	Min       *float64 `form:"min" json:"min"`
+	Max       *float64 `form:"max" json:"max"`
+	NoDecimal bool     `form:"noDecimal" json:"noDecimal"`
 }
 
 func (o NumberOptions) Validate() error {
 	var maxRules []validation.Rule
 	if o.Min != nil && o.Max != nil {
-		maxRules = append(maxRules, validation.Min(*o.Min))
+		maxRules = append(maxRules, validation.Min(*o.Min), validation.By(o.checkNoDecimal))
 	}
 
 	return validation.ValidateStruct(&o,
+		validation.Field(&o.Min, validation.By(o.checkNoDecimal)),
 		validation.Field(&o.Max, maxRules...),
 	)
 }
 
+func (o *NumberOptions) checkNoDecimal(value any) error {
+	v, _ := value.(*float64)
+	if v == nil || !o.NoDecimal {
+		return nil // nothing to check
+	}
+
+	if *v != float64(int64(*v)) {
+		return validation.NewError("validation_no_decimal_constraint", "Decimal numbers are not allowed.")
+	}
+
+	return nil
+}
+
 // -------------------------------------------------------------------
 
 type BoolOptions struct {
@@ -515,6 +538,12 @@ func (o UrlOptions) Validate() error {
 // -------------------------------------------------------------------
 
 type EditorOptions struct {
+	// ConvertUrls is usually used to instruct the editor whether to
+	// apply url conversion (eg. stripping the domain name in case the
+	// urls are using the same domain as the one where the editor is loaded).
+	//
+	// (see also https://www.tiny.cloud/docs/tinymce/6/url-handling/#convert_urls)
+	ConvertUrls bool `form:"convertUrls" json:"convertUrls"`
 }
 
 func (o EditorOptions) Validate() error {
@@ -641,7 +670,8 @@ type RelationOptions struct {
 	// If nil no limits are applied.
 	MaxSelect *int `form:"maxSelect" json:"maxSelect"`
 
-	// DisplayFields is optional slice of collection field names used for UI purposes.
+	// Deprecated: This field is no-op and will be removed in future versions.
+	// Instead use the individula SchemaField.Presentable option for each field in the relation collection.
 	DisplayFields []string `form:"displayFields" json:"displayFields"`
 }
 
@@ -653,7 +683,7 @@ func (o RelationOptions) Validate() error {
 
 	return validation.ValidateStruct(&o,
 		validation.Field(&o.CollectionId, validation.Required),
-		validation.Field(&o.MinSelect, validation.NilOrNotEmpty, validation.Min(1)),
+		validation.Field(&o.MinSelect, validation.Min(0)),
 		validation.Field(&o.MaxSelect, validation.NilOrNotEmpty, validation.Min(minVal)),
 	)
 }

models/schema/schema_field_test.go

@@ -63,47 +63,59 @@ func TestSchemaFieldColDefinition(t *testing.T) {
 	}{
 		{
 			schema.SchemaField{Type: schema.FieldTypeText, Name: "test"},
-			"TEXT DEFAULT ''",
+			"TEXT DEFAULT '' NOT NULL",
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeNumber, Name: "test"},
-			"NUMERIC DEFAULT 0",
+			"NUMERIC DEFAULT 0 NOT NULL",
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeBool, Name: "test"},
-			"BOOLEAN DEFAULT FALSE",
+			"BOOLEAN DEFAULT FALSE NOT NULL",
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeEmail, Name: "test"},
-			"TEXT DEFAULT ''",
+			"TEXT DEFAULT '' NOT NULL",
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeUrl, Name: "test"},
-			"TEXT DEFAULT ''",
+			"TEXT DEFAULT '' NOT NULL",
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeEditor, Name: "test"},
-			"TEXT DEFAULT ''",
+			"TEXT DEFAULT '' NOT NULL",
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeDate, Name: "test"},
-			"TEXT DEFAULT ''",
-		},
-		{
-			schema.SchemaField{Type: schema.FieldTypeSelect, Name: "test"},
-			"TEXT DEFAULT ''",
+			"TEXT DEFAULT '' NOT NULL",
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeJson, Name: "test"},
 			"JSON DEFAULT NULL",
 		},
 		{
-			schema.SchemaField{Type: schema.FieldTypeFile, Name: "test"},
-			"TEXT DEFAULT ''",
+			schema.SchemaField{Type: schema.FieldTypeSelect, Name: "test"},
+			"TEXT DEFAULT '' NOT NULL",
 		},
 		{
-			schema.SchemaField{Type: schema.FieldTypeRelation, Name: "test"},
-			"TEXT DEFAULT ''",
+			schema.SchemaField{Type: schema.FieldTypeSelect, Name: "test_multiple", Options: &schema.SelectOptions{MaxSelect: 2}},
+			"JSON DEFAULT '[]' NOT NULL",
+		},
+		{
+			schema.SchemaField{Type: schema.FieldTypeFile, Name: "test"},
+			"TEXT DEFAULT '' NOT NULL",
+		},
+		{
+			schema.SchemaField{Type: schema.FieldTypeFile, Name: "test_multiple", Options: &schema.FileOptions{MaxSelect: 2}},
+			"JSON DEFAULT '[]' NOT NULL",
+		},
+		{
+			schema.SchemaField{Type: schema.FieldTypeRelation, Name: "test", Options: &schema.RelationOptions{MaxSelect: types.Pointer(1)}},
+			"TEXT DEFAULT '' NOT NULL",
+		},
+		{
+			schema.SchemaField{Type: schema.FieldTypeRelation, Name: "test_multiple", Options: &schema.RelationOptions{MaxSelect: nil}},
+			"JSON DEFAULT '[]' NOT NULL",
 		},
 	}
 
@@ -117,19 +129,19 @@ func TestSchemaFieldColDefinition(t *testing.T) {
 
 func TestSchemaFieldString(t *testing.T) {
 	f := schema.SchemaField{
-		Id:       "abc",
-		Name:     "test",
-		Type:     schema.FieldTypeText,
-		Required: true,
-		Unique:   false,
-		System:   true,
+		Id:          "abc",
+		Name:        "test",
+		Type:        schema.FieldTypeText,
+		Required:    true,
+		Presentable: true,
+		System:      true,
 		Options: &schema.TextOptions{
 			Pattern: "test",
 		},
 	}
 
 	result := f.String()
-	expected := `{"system":true,"id":"abc","name":"test","type":"text","required":true,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`
+	expected := `{"system":true,"id":"abc","name":"test","type":"text","required":true,"presentable":true,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`
 
 	if result != expected {
 		t.Errorf("Expected \n%v, got \n%v", expected, result)
@@ -144,19 +156,19 @@ func TestSchemaFieldMarshalJSON(t *testing.T) {
 		// empty
 		{
 			schema.SchemaField{},
-			`{"system":false,"id":"","name":"","type":"","required":false,"unique":false,"options":null}`,
+			`{"system":false,"id":"","name":"","type":"","required":false,"presentable":false,"unique":false,"options":null}`,
 		},
 		// without defined options
 		{
 			schema.SchemaField{
-				Id:       "abc",
-				Name:     "test",
-				Type:     schema.FieldTypeText,
-				Required: true,
-				Unique:   false,
-				System:   true,
+				Id:          "abc",
+				Name:        "test",
+				Type:        schema.FieldTypeText,
+				Required:    true,
+				Presentable: true,
+				System:      true,
 			},
-			`{"system":true,"id":"abc","name":"test","type":"text","required":true,"unique":false,"options":{"min":null,"max":null,"pattern":""}}`,
+			`{"system":true,"id":"abc","name":"test","type":"text","required":true,"presentable":true,"unique":false,"options":{"min":null,"max":null,"pattern":""}}`,
 		},
 		// with defined options
 		{
@@ -170,7 +182,7 @@ func TestSchemaFieldMarshalJSON(t *testing.T) {
 					Pattern: "test",
 				},
 			},
-			`{"system":true,"id":"","name":"test","type":"text","required":true,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`,
+			`{"system":true,"id":"","name":"test","type":"text","required":true,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`,
 		},
 	}
 
@@ -195,32 +207,32 @@ func TestSchemaFieldUnmarshalJSON(t *testing.T) {
 		{
 			nil,
 			true,
-			`{"system":false,"id":"","name":"","type":"","required":false,"unique":false,"options":null}`,
+			`{"system":false,"id":"","name":"","type":"","required":false,"presentable":false,"unique":false,"options":null}`,
 		},
 		{
 			[]byte{},
 			true,
-			`{"system":false,"id":"","name":"","type":"","required":false,"unique":false,"options":null}`,
+			`{"system":false,"id":"","name":"","type":"","required":false,"presentable":false,"unique":false,"options":null}`,
 		},
 		{
 			[]byte(`{"system": true}`),
 			true,
-			`{"system":true,"id":"","name":"","type":"","required":false,"unique":false,"options":null}`,
+			`{"system":true,"id":"","name":"","type":"","required":false,"presentable":false,"unique":false,"options":null}`,
 		},
 		{
 			[]byte(`{"invalid"`),
 			true,
-			`{"system":false,"id":"","name":"","type":"","required":false,"unique":false,"options":null}`,
+			`{"system":false,"id":"","name":"","type":"","required":false,"presentable":false,"unique":false,"options":null}`,
 		},
 		{
 			[]byte(`{"type":"text","system":true}`),
 			false,
-			`{"system":true,"id":"","name":"","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}`,
+			`{"system":true,"id":"","name":"","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}`,
 		},
 		{
 			[]byte(`{"type":"text","options":{"pattern":"test"}}`),
 			false,
-			`{"system":false,"id":"","name":"","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`,
+			`{"system":false,"id":"","name":"","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`,
 		},
 	}
 
@@ -313,6 +325,15 @@ func TestSchemaFieldValidate(t *testing.T) {
 			},
 			[]string{"name"},
 		},
+		{
+			"reserved name (_rowid_)",
+			schema.SchemaField{
+				Type: schema.FieldTypeText,
+				Id:   "1234567890",
+				Name: "_rowid_",
+			},
+			[]string{"name"},
+		},
 		{
 			"reserved name (id)",
 			schema.SchemaField{
@@ -449,72 +470,72 @@ func TestSchemaFieldInitOptions(t *testing.T) {
 		{
 			schema.SchemaField{},
 			true,
-			`{"system":false,"id":"","name":"","type":"","required":false,"unique":false,"options":null}`,
+			`{"system":false,"id":"","name":"","type":"","required":false,"presentable":false,"unique":false,"options":null}`,
 		},
 		{
 			schema.SchemaField{Type: "unknown"},
 			true,
-			`{"system":false,"id":"","name":"","type":"unknown","required":false,"unique":false,"options":null}`,
+			`{"system":false,"id":"","name":"","type":"unknown","required":false,"presentable":false,"unique":false,"options":null}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeText},
 			false,
-			`{"system":false,"id":"","name":"","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}`,
+			`{"system":false,"id":"","name":"","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeNumber},
 			false,
-			`{"system":false,"id":"","name":"","type":"number","required":false,"unique":false,"options":{"min":null,"max":null}}`,
+			`{"system":false,"id":"","name":"","type":"number","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"noDecimal":false}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeBool},
 			false,
-			`{"system":false,"id":"","name":"","type":"bool","required":false,"unique":false,"options":{}}`,
+			`{"system":false,"id":"","name":"","type":"bool","required":false,"presentable":false,"unique":false,"options":{}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeEmail},
 			false,
-			`{"system":false,"id":"","name":"","type":"email","required":false,"unique":false,"options":{"exceptDomains":null,"onlyDomains":null}}`,
+			`{"system":false,"id":"","name":"","type":"email","required":false,"presentable":false,"unique":false,"options":{"exceptDomains":null,"onlyDomains":null}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeUrl},
 			false,
-			`{"system":false,"id":"","name":"","type":"url","required":false,"unique":false,"options":{"exceptDomains":null,"onlyDomains":null}}`,
+			`{"system":false,"id":"","name":"","type":"url","required":false,"presentable":false,"unique":false,"options":{"exceptDomains":null,"onlyDomains":null}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeEditor},
 			false,
-			`{"system":false,"id":"","name":"","type":"editor","required":false,"unique":false,"options":{}}`,
+			`{"system":false,"id":"","name":"","type":"editor","required":false,"presentable":false,"unique":false,"options":{"convertUrls":false}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeDate},
 			false,
-			`{"system":false,"id":"","name":"","type":"date","required":false,"unique":false,"options":{"min":"","max":""}}`,
+			`{"system":false,"id":"","name":"","type":"date","required":false,"presentable":false,"unique":false,"options":{"min":"","max":""}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeSelect},
 			false,
-			`{"system":false,"id":"","name":"","type":"select","required":false,"unique":false,"options":{"maxSelect":0,"values":null}}`,
+			`{"system":false,"id":"","name":"","type":"select","required":false,"presentable":false,"unique":false,"options":{"maxSelect":0,"values":null}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeJson},
 			false,
-			`{"system":false,"id":"","name":"","type":"json","required":false,"unique":false,"options":{}}`,
+			`{"system":false,"id":"","name":"","type":"json","required":false,"presentable":false,"unique":false,"options":{}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeFile},
 			false,
-			`{"system":false,"id":"","name":"","type":"file","required":false,"unique":false,"options":{"maxSelect":0,"maxSize":0,"mimeTypes":null,"thumbs":null,"protected":false}}`,
+			`{"system":false,"id":"","name":"","type":"file","required":false,"presentable":false,"unique":false,"options":{"maxSelect":0,"maxSize":0,"mimeTypes":null,"thumbs":null,"protected":false}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeRelation},
 			false,
-			`{"system":false,"id":"","name":"","type":"relation","required":false,"unique":false,"options":{"collectionId":"","cascadeDelete":false,"minSelect":null,"maxSelect":null,"displayFields":null}}`,
+			`{"system":false,"id":"","name":"","type":"relation","required":false,"presentable":false,"unique":false,"options":{"collectionId":"","cascadeDelete":false,"minSelect":null,"maxSelect":null,"displayFields":null}}`,
 		},
 		{
 			schema.SchemaField{Type: schema.FieldTypeUser},
 			false,
-			`{"system":false,"id":"","name":"","type":"user","required":false,"unique":false,"options":{"maxSelect":0,"cascadeDelete":false}}`,
+			`{"system":false,"id":"","name":"","type":"user","required":false,"presentable":false,"unique":false,"options":{"maxSelect":0,"cascadeDelete":false}}`,
 		},
 		{
 			schema.SchemaField{
@@ -522,7 +543,7 @@ func TestSchemaFieldInitOptions(t *testing.T) {
 				Options: &schema.TextOptions{Pattern: "test"},
 			},
 			false,
-			`{"system":false,"id":"","name":"","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`,
+			`{"system":false,"id":"","name":"","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}`,
 		},
 	}
 
@@ -1722,8 +1743,12 @@ func TestTextOptionsValidate(t *testing.T) {
 }
 
 func TestNumberOptionsValidate(t *testing.T) {
-	number1 := 10.0
-	number2 := 20.0
+	int1 := 10.0
+	int2 := 20.0
+
+	decimal1 := 10.5
+	decimal2 := 20.5
+
 	scenarios := []fieldOptionsScenario{
 		{
 			"empty",
@@ -1733,23 +1758,41 @@ func TestNumberOptionsValidate(t *testing.T) {
 		{
 			"max - without min",
 			schema.NumberOptions{
-				Max: &number1,
+				Max: &int1,
 			},
 			[]string{},
 		},
 		{
 			"max - failure with min",
 			schema.NumberOptions{
-				Min: &number2,
-				Max: &number1,
+				Min: &int2,
+				Max: &int1,
 			},
 			[]string{"max"},
 		},
 		{
 			"max - success with min",
 			schema.NumberOptions{
-				Min: &number1,
-				Max: &number2,
+				Min: &int1,
+				Max: &int2,
+			},
+			[]string{},
+		},
+		{
+			"NoDecimal range failure",
+			schema.NumberOptions{
+				Min:       &decimal1,
+				Max:       &decimal2,
+				NoDecimal: true,
+			},
+			[]string{"min", "max"},
+		},
+		{
+			"NoDecimal range success",
+			schema.NumberOptions{
+				Min:       &int1,
+				Max:       &int2,
+				NoDecimal: true,
 			},
 			[]string{},
 		},
@@ -2112,6 +2155,22 @@ func TestRelationOptionsValidate(t *testing.T) {
 			},
 			[]string{"collectionId"},
 		},
+		{
+			"MinSelect < 0",
+			schema.RelationOptions{
+				CollectionId: "abc",
+				MinSelect:    types.Pointer(-1),
+			},
+			[]string{"minSelect"},
+		},
+		{
+			"MinSelect >= 0",
+			schema.RelationOptions{
+				CollectionId: "abc",
+				MinSelect:    types.Pointer(0),
+			},
+			[]string{},
+		},
 		{
 			"MaxSelect <= 0",
 			schema.RelationOptions{
@@ -2128,6 +2187,42 @@ func TestRelationOptionsValidate(t *testing.T) {
 			},
 			[]string{},
 		},
+		{
+			"MinSelect < MaxSelect",
+			schema.RelationOptions{
+				CollectionId: "abc",
+				MinSelect:    nil,
+				MaxSelect:    types.Pointer(1),
+			},
+			[]string{},
+		},
+		{
+			"MinSelect = MaxSelect (non-zero)",
+			schema.RelationOptions{
+				CollectionId: "abc",
+				MinSelect:    types.Pointer(1),
+				MaxSelect:    types.Pointer(1),
+			},
+			[]string{},
+		},
+		{
+			"MinSelect = MaxSelect (both zero)",
+			schema.RelationOptions{
+				CollectionId: "abc",
+				MinSelect:    types.Pointer(0),
+				MaxSelect:    types.Pointer(0),
+			},
+			[]string{"maxSelect"},
+		},
+		{
+			"MinSelect > MaxSelect",
+			schema.RelationOptions{
+				CollectionId: "abc",
+				MinSelect:    types.Pointer(2),
+				MaxSelect:    types.Pointer(1),
+			},
+			[]string{"maxSelect"},
+		},
 	}
 
 	checkFieldOptionsScenarios(t, scenarios)

models/schema/schema_test.go

@@ -286,7 +286,7 @@ func TestSchemaMarshalJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	expected := `[{"system":false,"id":"f1id","name":"test1","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}},{"system":false,"id":"f2id","name":"test2","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}]`
+	expected := `[{"system":false,"id":"f1id","name":"test1","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}},{"system":false,"id":"f2id","name":"test2","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}]`
 
 	if string(result) != expected {
 		t.Fatalf("Expected %s, got %s", expected, string(result))
@@ -354,7 +354,7 @@ func TestSchemaValue(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	expected := `[{"system":false,"id":"f1id","name":"test1","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`
+	expected := `[{"system":false,"id":"f1id","name":"test1","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`
 
 	if v2 != expected {
 		t.Fatalf("Expected %v, got %v", expected, v2)
@@ -377,21 +377,21 @@ func TestSchemaScan(t *testing.T) {
 		{`[{}]`, true, `[]`},
 		// unknown field type
 		{
-			`[{"system":false,"id":"123","name":"test1","type":"unknown","required":false,"unique":false}]`,
+			`[{"system":false,"id":"123","name":"test1","type":"unknown","required":false,"presentable":false,"unique":false}]`,
 			true,
 			`[]`,
 		},
 		// without options
 		{
-			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"unique":false}]`,
+			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"presentable":false,"unique":false}]`,
 			false,
-			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`,
+			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":""}}]`,
 		},
 		// with options
 		{
-			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}]`,
+			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}]`,
 			false,
-			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}]`,
+			`[{"system":false,"id":"123","name":"test1","type":"text","required":false,"presentable":false,"unique":false,"options":{"min":null,"max":null,"pattern":"test"}}]`,
 		},
 	}
 

models/settings/settings.go

@@ -60,6 +60,11 @@ type Settings struct {
 	OIDC2Auth     AuthProviderConfig `form:"oidc2Auth" json:"oidc2Auth"`
 	OIDC3Auth     AuthProviderConfig `form:"oidc3Auth" json:"oidc3Auth"`
 	AppleAuth     AuthProviderConfig `form:"appleAuth" json:"appleAuth"`
+	InstagramAuth AuthProviderConfig `form:"instagramAuth" json:"instagramAuth"`
+	VKAuth        AuthProviderConfig `form:"vkAuth" json:"vkAuth"`
+	YandexAuth    AuthProviderConfig `form:"yandexAuth" json:"yandexAuth"`
+	PatreonAuth   AuthProviderConfig `form:"patreonAuth" json:"patreonAuth"`
+	MailcowAuth   AuthProviderConfig `form:"mailcowAuth" json:"mailcowAuth"`
 }
 
 // New creates and returns a new default Settings instance.
@@ -175,6 +180,21 @@ func New() *Settings {
 		AppleAuth: AuthProviderConfig{
 			Enabled: false,
 		},
+		InstagramAuth: AuthProviderConfig{
+			Enabled: false,
+		},
+		VKAuth: AuthProviderConfig{
+			Enabled: false,
+		},
+		YandexAuth: AuthProviderConfig{
+			Enabled: false,
+		},
+		PatreonAuth: AuthProviderConfig{
+			Enabled: false,
+		},
+		MailcowAuth: AuthProviderConfig{
+			Enabled: false,
+		},
 	}
 }
 
@@ -215,6 +235,11 @@ func (s *Settings) Validate() error {
 		validation.Field(&s.OIDC2Auth),
 		validation.Field(&s.OIDC3Auth),
 		validation.Field(&s.AppleAuth),
+		validation.Field(&s.InstagramAuth),
+		validation.Field(&s.VKAuth),
+		validation.Field(&s.YandexAuth),
+		validation.Field(&s.PatreonAuth),
+		validation.Field(&s.MailcowAuth),
 	)
 }
 
@@ -278,6 +303,11 @@ func (s *Settings) RedactClone() (*Settings, error) {
 		&clone.OIDC2Auth.ClientSecret,
 		&clone.OIDC3Auth.ClientSecret,
 		&clone.AppleAuth.ClientSecret,
+		&clone.InstagramAuth.ClientSecret,
+		&clone.VKAuth.ClientSecret,
+		&clone.YandexAuth.ClientSecret,
+		&clone.PatreonAuth.ClientSecret,
+		&clone.MailcowAuth.ClientSecret,
 	}
 
 	// mask all sensitive fields
@@ -315,6 +345,11 @@ func (s *Settings) NamedAuthProviderConfigs() map[string]AuthProviderConfig {
 		auth.NameOIDC + "2": s.OIDC2Auth,
 		auth.NameOIDC + "3": s.OIDC3Auth,
 		auth.NameApple:      s.AppleAuth,
+		auth.NameInstagram:  s.InstagramAuth,
+		auth.NameVK:         s.VKAuth,
+		auth.NameYandex:     s.YandexAuth,
+		auth.NamePatreon:    s.PatreonAuth,
+		auth.NameMailcow:    s.MailcowAuth,
 	}
 }
 
@@ -350,6 +385,12 @@ type SmtpConfig struct {
 	// When set to false StartTLS command is send, leaving the server
 	// to decide whether to upgrade the connection or not.
 	Tls bool `form:"tls" json:"tls"`
+
+	// LocalName is optional domain name or IP address used for the
+	// EHLO/HELO exchange (if not explicitly set, defaults to "localhost").
+	//
+	// This is required only by some SMTP servers, such as Gmail SMTP-relay.
+	LocalName string `form:"localName" json:"localName"`
 }
 
 // Validate makes SmtpConfig validatable by implementing [validation.Validatable] interface.
@@ -372,6 +413,7 @@ func (c SmtpConfig) Validate() error {
 			// validation.When(c.Enabled, validation.Required),
 			validation.In(mailer.SmtpAuthLogin, mailer.SmtpAuthPlain),
 		),
+		validation.Field(&c.LocalName, is.Host),
 	)
 }
 

models/settings/settings_test.go

@@ -67,6 +67,16 @@ func TestSettingsValidate(t *testing.T) {
 	s.OIDC3Auth.ClientId = ""
 	s.AppleAuth.Enabled = true
 	s.AppleAuth.ClientId = ""
+	s.InstagramAuth.Enabled = true
+	s.InstagramAuth.ClientId = ""
+	s.VKAuth.Enabled = true
+	s.VKAuth.ClientId = ""
+	s.YandexAuth.Enabled = true
+	s.YandexAuth.ClientId = ""
+	s.PatreonAuth.Enabled = true
+	s.PatreonAuth.ClientId = ""
+	s.MailcowAuth.Enabled = true
+	s.MailcowAuth.ClientId = ""
 
 	// check if Validate() is triggering the members validate methods.
 	err := s.Validate()
@@ -105,6 +115,11 @@ func TestSettingsValidate(t *testing.T) {
 		`"oidc2Auth":{`,
 		`"oidc3Auth":{`,
 		`"appleAuth":{`,
+		`"instagramAuth":{`,
+		`"vkAuth":{`,
+		`"yandexAuth":{`,
+		`"patreonAuth":{`,
+		`"mailcowAuth":{`,
 	}
 
 	errBytes, _ := json.Marshal(err)
@@ -172,6 +187,16 @@ func TestSettingsMerge(t *testing.T) {
 	s2.OIDC3Auth.ClientId = "oidc3_test"
 	s2.AppleAuth.Enabled = true
 	s2.AppleAuth.ClientId = "apple_test"
+	s2.InstagramAuth.Enabled = true
+	s2.InstagramAuth.ClientId = "instagram_test"
+	s2.VKAuth.Enabled = true
+	s2.VKAuth.ClientId = "vk_test"
+	s2.YandexAuth.Enabled = true
+	s2.YandexAuth.ClientId = "yandex_test"
+	s2.PatreonAuth.Enabled = true
+	s2.PatreonAuth.ClientId = "patreon_test"
+	s2.MailcowAuth.Enabled = true
+	s2.MailcowAuth.ClientId = "mailcow_test"
 
 	if err := s1.Merge(s2); err != nil {
 		t.Fatal(err)
@@ -259,6 +284,11 @@ func TestSettingsRedactClone(t *testing.T) {
 	s1.OIDC2Auth.ClientSecret = testSecret
 	s1.OIDC3Auth.ClientSecret = testSecret
 	s1.AppleAuth.ClientSecret = testSecret
+	s1.InstagramAuth.ClientSecret = testSecret
+	s1.VKAuth.ClientSecret = testSecret
+	s1.YandexAuth.ClientSecret = testSecret
+	s1.PatreonAuth.ClientSecret = testSecret
+	s1.MailcowAuth.ClientSecret = testSecret
 
 	s1Bytes, err := json.Marshal(s1)
 	if err != nil {
@@ -314,6 +344,11 @@ func TestNamedAuthProviderConfigs(t *testing.T) {
 	s.OIDC2Auth.ClientId = "oidc2_test"
 	s.OIDC3Auth.ClientId = "oidc3_test"
 	s.AppleAuth.ClientId = "apple_test"
+	s.InstagramAuth.ClientId = "instagram_test"
+	s.VKAuth.ClientId = "vk_test"
+	s.YandexAuth.ClientId = "yandex_test"
+	s.PatreonAuth.ClientId = "patreon_test"
+	s.MailcowAuth.ClientId = "mailcow_test"
 
 	result := s.NamedAuthProviderConfigs()
 
@@ -342,6 +377,11 @@ func TestNamedAuthProviderConfigs(t *testing.T) {
 		`"oidc2":{"enabled":false,"clientId":"oidc2_test"`,
 		`"oidc3":{"enabled":false,"clientId":"oidc3_test"`,
 		`"apple":{"enabled":false,"clientId":"apple_test"`,
+		`"instagram":{"enabled":false,"clientId":"instagram_test"`,
+		`"vk":{"enabled":false,"clientId":"vk_test"`,
+		`"yandex":{"enabled":false,"clientId":"yandex_test"`,
+		`"patreon":{"enabled":false,"clientId":"patreon_test"`,
+		`"mailcow":{"enabled":false,"clientId":"mailcow_test"`,
 	}
 	for _, p := range expectedParts {
 		if !strings.Contains(encodedStr, p) {
@@ -453,6 +493,26 @@ func TestSmtpConfigValidate(t *testing.T) {
 			},
 			false,
 		},
+		// invalid ehlo/helo name
+		{
+			settings.SmtpConfig{
+				Enabled:   true,
+				Host:      "example.com",
+				Port:      100,
+				LocalName: "invalid!",
+			},
+			true,
+		},
+		// valid ehlo/helo name
+		{
+			settings.SmtpConfig{
+				Enabled:   true,
+				Host:      "example.com",
+				Port:      100,
+				LocalName: "example.com",
+			},
+			false,
+		},
 	}
 
 	for i, scenario := range scenarios {

plugins/ghupdate/ghupdate.go

@@ -1,5 +1,9 @@
 // Package ghupdate implements a new command to selfupdate the current
 // PocketBase executable with the latest GitHub release.
+//
+// Example usage:
+//
+//	ghupdate.MustRegister(app, app.RootCmd, ghupdate.Config{})
 package ghupdate
 
 import (
@@ -11,11 +15,12 @@ import (
 	"log"
 	"net/http"
 	"os"
-	"path"
 	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/fatih/color"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/archive"
@@ -27,17 +32,18 @@ type HttpClient interface {
 	Do(req *http.Request) (*http.Response, error)
 }
 
-// Options defines optional struct to customize the default plugin behavior.
+// Config defines the config options of the ghupdate plugin.
 //
-// NB! This plugin is considered experimental and its options may change in the future.
-type Options struct {
+// NB! This plugin is considered experimental and its config options may change in the future.
+type Config struct {
 	// Owner specifies the account owner of the repository (default to "pocketbase").
 	Owner string
 
 	// Repo specifies the name of the repository (default to "pocketbase").
 	Repo string
 
-	// ArchiveExecutable specifies the name of the executable file in the release archive (default to "pocketbase").
+	// ArchiveExecutable specifies the name of the executable file in the release archive
+	// (default to "pocketbase"; an additional ".exe" check is also performed as a fallback).
 	ArchiveExecutable string
 
 	// Optional context to use when fetching and downloading the latest release.
@@ -50,43 +56,38 @@ type Options struct {
 
 // MustRegister registers the ghupdate plugin to the provided app instance
 // and panic if it fails.
-func MustRegister(app core.App, rootCmd *cobra.Command, options *Options) {
-	if err := Register(app, rootCmd, options); err != nil {
+func MustRegister(app core.App, rootCmd *cobra.Command, config Config) {
+	if err := Register(app, rootCmd, config); err != nil {
 		panic(err)
 	}
 }
 
 // Register registers the ghupdate plugin to the provided app instance.
-func Register(app core.App, rootCmd *cobra.Command, options *Options) error {
+func Register(app core.App, rootCmd *cobra.Command, config Config) error {
 	p := &plugin{
 		app:            app,
 		currentVersion: rootCmd.Version,
+		config:         config,
 	}
 
-	if options != nil {
-		p.options = options
-	} else {
-		p.options = &Options{}
+	if p.config.Owner == "" {
+		p.config.Owner = "pocketbase"
 	}
 
-	if p.options.Owner == "" {
-		p.options.Owner = "pocketbase"
+	if p.config.Repo == "" {
+		p.config.Repo = "pocketbase"
 	}
 
-	if p.options.Repo == "" {
-		p.options.Repo = "pocketbase"
+	if p.config.ArchiveExecutable == "" {
+		p.config.ArchiveExecutable = "pocketbase"
 	}
 
-	if p.options.ArchiveExecutable == "" {
-		p.options.ArchiveExecutable = "pocketbase"
+	if p.config.HttpClient == nil {
+		p.config.HttpClient = http.DefaultClient
 	}
 
-	if p.options.HttpClient == nil {
-		p.options.HttpClient = http.DefaultClient
-	}
-
-	if p.options.Context == nil {
-		p.options.Context = context.Background()
+	if p.config.Context == nil {
+		p.config.Context = context.Background()
 	}
 
 	rootCmd.AddCommand(p.updateCmd())
@@ -97,7 +98,7 @@ func Register(app core.App, rootCmd *cobra.Command, options *Options) error {
 type plugin struct {
 	app            core.App
 	currentVersion string
-	options        *Options
+	config         Config
 }
 
 func (p *plugin) updateCmd() *cobra.Command {
@@ -111,6 +112,29 @@ func (p *plugin) updateCmd() *cobra.Command {
 		SilenceErrors: true,
 		SilenceUsage:  true,
 		RunE: func(command *cobra.Command, args []string) error {
+			var needConfirm bool
+			if isMaybeRunningInDocker() {
+				needConfirm = true
+				color.Yellow("NB! It seems that you are in a Docker container.")
+				color.Yellow("The update command may not work as expected in this context because usually the version of the app is managed by the container image itself.")
+			} else if isMaybeRunningInNixOS() {
+				needConfirm = true
+				color.Yellow("NB! It seems that you are in a NixOS.")
+				color.Yellow("Due to the non-standard filesystem implementation of the environment, the update command may not work as expected.")
+			}
+
+			if needConfirm {
+				confirm := false
+				prompt := &survey.Confirm{
+					Message: "Do you want to proceed with the update?",
+				}
+				survey.AskOne(prompt, &confirm)
+				if !confirm {
+					fmt.Println("The command has been cancelled.")
+					return nil
+				}
+			}
+
 			return p.update(withBackup)
 		},
 	}
@@ -129,16 +153,16 @@ func (p *plugin) update(withBackup bool) error {
 	color.Yellow("Fetching release information...")
 
 	latest, err := fetchLatestRelease(
-		p.options.Context,
-		p.options.HttpClient,
-		p.options.Owner,
-		p.options.Repo,
+		p.config.Context,
+		p.config.HttpClient,
+		p.config.Owner,
+		p.config.Repo,
 	)
 	if err != nil {
 		return err
 	}
 
-	if strings.TrimPrefix(p.currentVersion, "v") >= strings.TrimPrefix(latest.Tag, "v") {
+	if compareVersions(strings.TrimPrefix(p.currentVersion, "v"), strings.TrimPrefix(latest.Tag, "v")) <= 0 {
 		color.Green("You already have the latest PocketBase %s.", p.currentVersion)
 		return nil
 	}
@@ -153,20 +177,20 @@ func (p *plugin) update(withBackup bool) error {
 		return err
 	}
 
-	releaseDir := path.Join(p.app.DataDir(), core.LocalTempDirName)
+	releaseDir := filepath.Join(p.app.DataDir(), core.LocalTempDirName)
 	defer os.RemoveAll(releaseDir)
 
 	color.Yellow("Downloading %s...", asset.Name)
 
 	// download the release asset
-	assetZip := path.Join(releaseDir, asset.Name)
-	if err := downloadFile(p.options.Context, p.options.HttpClient, asset.DownloadUrl, assetZip); err != nil {
+	assetZip := filepath.Join(releaseDir, asset.Name)
+	if err := downloadFile(p.config.Context, p.config.HttpClient, asset.DownloadUrl, assetZip); err != nil {
 		return err
 	}
 
 	color.Yellow("Extracting %s...", asset.Name)
 
-	extractDir := path.Join(releaseDir, "extracted_"+asset.Name)
+	extractDir := filepath.Join(releaseDir, "extracted_"+asset.Name)
 	defer os.RemoveAll(extractDir)
 
 	if err := archive.Extract(assetZip, extractDir); err != nil {
@@ -182,7 +206,14 @@ func (p *plugin) update(withBackup bool) error {
 	renamedOldExec := oldExec + ".old"
 	defer os.Remove(renamedOldExec)
 
-	newExec := path.Join(extractDir, p.options.ArchiveExecutable)
+	newExec := filepath.Join(extractDir, p.config.ArchiveExecutable)
+	if _, err := os.Stat(newExec); err != nil {
+		// try again with an .exe extension
+		newExec = newExec + ".exe"
+		if _, fallbackErr := os.Stat(newExec); fallbackErr != nil {
+			return fmt.Errorf("The executable in the extracted path is missing or it is inaccessible: %v, %v", err, fallbackErr)
+		}
+	}
 
 	// rename the current executable
 	if err := os.Rename(oldExec, renamedOldExec); err != nil {
@@ -205,14 +236,24 @@ func (p *plugin) update(withBackup bool) error {
 		color.Yellow("Creating pb_data backup...")
 
 		backupName := fmt.Sprintf("@update_%s.zip", latest.Tag)
-		if err := p.app.CreateBackup(p.options.Context, backupName); err != nil {
+		if err := p.app.CreateBackup(p.config.Context, backupName); err != nil {
 			tryToRevertExecChanges()
 			return err
 		}
 	}
 
 	color.HiBlack("---")
-	color.Green("Update completed sucessfully! You can start the executable as usual.")
+	color.Green("Update completed successfully! You can start the executable as usual.")
+
+	// print the release notes
+	if latest.Body != "" {
+		fmt.Print("\n")
+		color.Cyan("Here is a list with some of the %s changes:", latest.Tag)
+		// remove the update command note to avoid "stuttering"
+		releaseNotes := strings.TrimSpace(strings.Replace(latest.Body, "> _To update the prebuilt executable you can run `./pocketbase update`._", "", 1))
+		color.Cyan(releaseNotes)
+		fmt.Print("\n")
+	}
 
 	return nil
 }
@@ -327,3 +368,51 @@ func archiveSuffix(goos, goarch string) string {
 
 	return ""
 }
+
+func compareVersions(a, b string) int {
+	aSplit := strings.Split(a, ".")
+	aTotal := len(aSplit)
+
+	bSplit := strings.Split(b, ".")
+	bTotal := len(bSplit)
+
+	limit := aTotal
+	if bTotal > aTotal {
+		limit = bTotal
+	}
+
+	for i := 0; i < limit; i++ {
+		var x, y int
+
+		if i < aTotal {
+			x, _ = strconv.Atoi(aSplit[i])
+		}
+
+		if i < bTotal {
+			y, _ = strconv.Atoi(bSplit[i])
+		}
+
+		if x < y {
+			return 1 // b is newer
+		}
+
+		if x > y {
+			return -1 // a is newer
+		}
+	}
+
+	return 0 // equal
+}
+
+// note: not completely reliable as it may not work on all platforms
+// but should at least provide a warning for the most common use cases
+func isMaybeRunningInDocker() bool {
+	_, err := os.Stat("/.dockerenv")
+	return err == nil
+}
+
+// note: untested
+func isMaybeRunningInNixOS() bool {
+	_, err := os.Stat("/etc/NIXOS")
+	return err == nil
+}

plugins/ghupdate/ghupdate_test.go

@@ -0,0 +1,35 @@
+package ghupdate
+
+import "testing"
+
+func TestCompareVersions(t *testing.T) {
+	scenarios := []struct {
+		a        string
+		b        string
+		expected int
+	}{
+		{"", "", 0},
+		{"0", "", 0},
+		{"1", "1.0.0", 0},
+		{"1.1", "1.1.0", 0},
+		{"1.1", "1.1.1", 1},
+		{"1.1", "1.0.1", -1},
+		{"1.0", "1.0.1", 1},
+		{"1.10", "1.9", -1},
+		{"1.2", "1.12", 1},
+		{"3.2", "1.6", -1},
+		{"0.0.2", "0.0.1", -1},
+		{"0.16.2", "0.17.0", 1},
+		{"1.15.0", "0.16.1", -1},
+		{"3.2", "4.0", 1},
+		{"3.2.4", "3.2.3", -1},
+	}
+
+	for i, s := range scenarios {
+		result := compareVersions(s.a, s.b)
+
+		if result != s.expected {
+			t.Fatalf("[%d] Expected %q vs %q to result in %d, got %d", i, s.a, s.b, s.expected, result)
+		}
+	}
+}

plugins/ghupdate/release.go

@@ -6,19 +6,20 @@ import (
 )
 
 type releaseAsset struct {
-	Id          int    `json:"id"`
 	Name        string `json:"name"`
-	Size        int    `json:"size"`
 	DownloadUrl string `json:"browser_download_url"`
+	Id          int    `json:"id"`
+	Size        int    `json:"size"`
 }
 
 type release struct {
-	Id        int             `json:"id"`
 	Name      string          `json:"name"`
 	Tag       string          `json:"tag_name"`
 	Published string          `json:"published_at"`
 	Url       string          `json:"html_url"`
+	Body      string          `json:"body"`
 	Assets    []*releaseAsset `json:"assets"`
+	Id        int             `json:"id"`
 }
 
 // findAssetBySuffix returns the first available asset containing the specified suffix.

plugins/jsvm/binds.go

@@ -0,0 +1,853 @@
+package jsvm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/dop251/goja"
+	validation "github.com/go-ozzo/ozzo-validation/v4"
+	"github.com/labstack/echo/v5"
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/forms"
+	"github.com/pocketbase/pocketbase/mails"
+	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/models/schema"
+	"github.com/pocketbase/pocketbase/tokens"
+	"github.com/pocketbase/pocketbase/tools/cron"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+	"github.com/pocketbase/pocketbase/tools/hook"
+	"github.com/pocketbase/pocketbase/tools/inflector"
+	"github.com/pocketbase/pocketbase/tools/list"
+	"github.com/pocketbase/pocketbase/tools/mailer"
+	"github.com/pocketbase/pocketbase/tools/rest"
+	"github.com/pocketbase/pocketbase/tools/security"
+	"github.com/pocketbase/pocketbase/tools/subscriptions"
+	"github.com/pocketbase/pocketbase/tools/types"
+	"github.com/spf13/cobra"
+)
+
+// hooksBinds adds wrapped "on*" hook methods by reflecting on core.App.
+func hooksBinds(app core.App, loader *goja.Runtime, executors *vmsPool) {
+	fm := FieldMapper{}
+
+	appType := reflect.TypeOf(app)
+	appValue := reflect.ValueOf(app)
+	totalMethods := appType.NumMethod()
+	excludeHooks := []string{"OnBeforeServe"}
+
+	for i := 0; i < totalMethods; i++ {
+		method := appType.Method(i)
+		if !strings.HasPrefix(method.Name, "On") || list.ExistInSlice(method.Name, excludeHooks) {
+			continue // not a hook or excluded
+		}
+
+		jsName := fm.MethodName(appType, method)
+
+		// register the hook to the loader
+		loader.Set(jsName, func(callback string, tags ...string) {
+			pr := goja.MustCompile("", "{("+callback+").apply(undefined, __args)}", true)
+
+			tagsAsValues := make([]reflect.Value, len(tags))
+			for i, tag := range tags {
+				tagsAsValues[i] = reflect.ValueOf(tag)
+			}
+
+			hookInstance := appValue.MethodByName(method.Name).Call(tagsAsValues)[0]
+			addFunc := hookInstance.MethodByName("Add")
+
+			handlerType := addFunc.Type().In(0)
+
+			handler := reflect.MakeFunc(handlerType, func(args []reflect.Value) (results []reflect.Value) {
+				handlerArgs := make([]any, len(args))
+				for i, arg := range args {
+					handlerArgs[i] = arg.Interface()
+				}
+
+				err := executors.run(func(executor *goja.Runtime) error {
+					executor.Set("__args", handlerArgs)
+					res, err := executor.RunProgram(pr)
+					executor.Set("__args", goja.Undefined())
+
+					// check for returned error or false
+					if res != nil {
+						switch v := res.Export().(type) {
+						case error:
+							return v
+						case bool:
+							if !v {
+								return hook.StopPropagation
+							}
+						}
+					}
+
+					return err
+				})
+
+				return []reflect.Value{reflect.ValueOf(&err).Elem()}
+			})
+
+			// register the wrapped hook handler
+			addFunc.Call([]reflect.Value{handler})
+		})
+	}
+}
+
+func cronBinds(app core.App, loader *goja.Runtime, executors *vmsPool) {
+	scheduler := cron.New()
+
+	var wasServeTriggered bool
+
+	loader.Set("cronAdd", func(jobId, cronExpr, handler string) {
+		pr := goja.MustCompile("", "{("+handler+").apply(undefined)}", true)
+
+		err := scheduler.Add(jobId, cronExpr, func() {
+			err := executors.run(func(executor *goja.Runtime) error {
+				_, err := executor.RunProgram(pr)
+				return err
+			})
+
+			if err != nil && app.IsDebug() {
+				fmt.Println("[cronAdd] failed to execute cron job " + jobId + ": " + err.Error())
+			}
+		})
+		if err != nil {
+			panic("[cronAdd] failed to register cron job " + jobId + ": " + err.Error())
+		}
+
+		// start the ticker (if not already)
+		if wasServeTriggered && scheduler.Total() > 0 && !scheduler.HasStarted() {
+			scheduler.Start()
+		}
+	})
+
+	loader.Set("cronRemove", func(jobId string) {
+		scheduler.Remove(jobId)
+
+		// stop the ticker if there are no other jobs
+		if scheduler.Total() == 0 {
+			scheduler.Stop()
+		}
+	})
+
+	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+		// start the ticker (if not already)
+		if scheduler.Total() > 0 && !scheduler.HasStarted() {
+			scheduler.Start()
+		}
+
+		wasServeTriggered = true
+
+		return nil
+	})
+}
+
+func routerBinds(app core.App, loader *goja.Runtime, executors *vmsPool) {
+	loader.Set("routerAdd", func(method string, path string, handler goja.Value, middlewares ...goja.Value) {
+		wrappedMiddlewares, err := wrapMiddlewares(executors, middlewares...)
+		if err != nil {
+			panic("[routerAdd] failed to wrap middlewares: " + err.Error())
+		}
+
+		wrappedHandler, err := wrapHandler(executors, handler)
+		if err != nil {
+			panic("[routerAdd] failed to wrap handler: " + err.Error())
+		}
+
+		app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+			e.Router.Add(strings.ToUpper(method), path, wrappedHandler, wrappedMiddlewares...)
+
+			return nil
+		})
+	})
+
+	loader.Set("routerUse", func(middlewares ...goja.Value) {
+		wrappedMiddlewares, err := wrapMiddlewares(executors, middlewares...)
+		if err != nil {
+			panic("[routerUse] failed to wrap middlewares: " + err.Error())
+		}
+
+		app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+			e.Router.Use(wrappedMiddlewares...)
+			return nil
+		})
+	})
+
+	loader.Set("routerPre", func(middlewares ...goja.Value) {
+		wrappedMiddlewares, err := wrapMiddlewares(executors, middlewares...)
+		if err != nil {
+			panic("[routerPre] failed to wrap middlewares: " + err.Error())
+		}
+
+		app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+			e.Router.Pre(wrappedMiddlewares...)
+			return nil
+		})
+	})
+}
+
+func wrapHandler(executors *vmsPool, handler goja.Value) (echo.HandlerFunc, error) {
+	if handler == nil {
+		return nil, errors.New("handler must be non-nil")
+	}
+
+	switch h := handler.Export().(type) {
+	case echo.HandlerFunc:
+		// "native" handler - no need to wrap
+		return h, nil
+	case func(goja.FunctionCall) goja.Value, string:
+		pr := goja.MustCompile("", "{("+handler.String()+").apply(undefined, __args)}", true)
+
+		wrappedHandler := func(c echo.Context) error {
+			return executors.run(func(executor *goja.Runtime) error {
+				executor.Set("__args", []any{c})
+				res, err := executor.RunProgram(pr)
+				executor.Set("__args", goja.Undefined())
+
+				// check for returned error
+				if res != nil {
+					if v, ok := res.Export().(error); ok {
+						return v
+					}
+				}
+
+				return err
+			})
+		}
+
+		return wrappedHandler, nil
+	default:
+		return nil, errors.New("unsupported goja handler type")
+	}
+}
+
+func wrapMiddlewares(executors *vmsPool, rawMiddlewares ...goja.Value) ([]echo.MiddlewareFunc, error) {
+	wrappedMiddlewares := make([]echo.MiddlewareFunc, len(rawMiddlewares))
+
+	for i, m := range rawMiddlewares {
+		if m == nil {
+			return nil, errors.New("middleware func must be non-nil")
+		}
+
+		switch v := m.Export().(type) {
+		case echo.MiddlewareFunc:
+			// "native" middleware - no need to wrap
+			wrappedMiddlewares[i] = v
+		case func(goja.FunctionCall) goja.Value, string:
+			pr := goja.MustCompile("", "{(("+m.String()+").apply(undefined, __args)).apply(undefined, __args2)}", true)
+
+			wrappedMiddlewares[i] = func(next echo.HandlerFunc) echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return executors.run(func(executor *goja.Runtime) error {
+						executor.Set("__args", []any{next})
+						executor.Set("__args2", []any{c})
+						res, err := executor.RunProgram(pr)
+						executor.Set("__args", goja.Undefined())
+						executor.Set("__args2", goja.Undefined())
+
+						// check for returned error
+						if res != nil {
+							if v, ok := res.Export().(error); ok {
+								return v
+							}
+						}
+
+						return err
+					})
+				}
+			}
+		default:
+			return nil, errors.New("unsupported goja middleware type")
+		}
+	}
+
+	return wrappedMiddlewares, nil
+}
+
+func baseBinds(vm *goja.Runtime) {
+	vm.SetFieldNameMapper(FieldMapper{})
+
+	vm.Set("readerToString", func(r io.Reader, maxBytes int) (string, error) {
+		if maxBytes == 0 {
+			maxBytes = rest.DefaultMaxMemory
+		}
+
+		limitReader := io.LimitReader(r, int64(maxBytes))
+
+		bodyBytes, readErr := io.ReadAll(limitReader)
+		if readErr != nil {
+			return "", readErr
+		}
+
+		return string(bodyBytes), nil
+	})
+
+	vm.Set("arrayOf", func(model any) any {
+		mt := reflect.TypeOf(model)
+		st := reflect.SliceOf(mt)
+		elem := reflect.New(st).Elem()
+
+		return elem.Addr().Interface()
+	})
+
+	vm.Set("DynamicModel", func(call goja.ConstructorCall) *goja.Object {
+		shape, ok := call.Argument(0).Export().(map[string]any)
+		if !ok || len(shape) == 0 {
+			panic("[DynamicModel] missing shape data")
+		}
+
+		instance := newDynamicModel(shape)
+		instanceValue := vm.ToValue(instance).(*goja.Object)
+		instanceValue.SetPrototype(call.This.Prototype())
+
+		return instanceValue
+	})
+
+	vm.Set("Record", func(call goja.ConstructorCall) *goja.Object {
+		var instance *models.Record
+
+		collection, ok := call.Argument(0).Export().(*models.Collection)
+		if ok {
+			instance = models.NewRecord(collection)
+			data, ok := call.Argument(1).Export().(map[string]any)
+			if ok {
+				instance.Load(data)
+			}
+		} else {
+			instance = &models.Record{}
+		}
+
+		instanceValue := vm.ToValue(instance).(*goja.Object)
+		instanceValue.SetPrototype(call.This.Prototype())
+
+		return instanceValue
+	})
+
+	vm.Set("Collection", func(call goja.ConstructorCall) *goja.Object {
+		instance := &models.Collection{}
+		return structConstructorUnmarshal(vm, call, instance)
+	})
+
+	vm.Set("Admin", func(call goja.ConstructorCall) *goja.Object {
+		instance := &models.Admin{}
+		return structConstructorUnmarshal(vm, call, instance)
+	})
+
+	vm.Set("Schema", func(call goja.ConstructorCall) *goja.Object {
+		instance := &schema.Schema{}
+		return structConstructorUnmarshal(vm, call, instance)
+	})
+
+	vm.Set("SchemaField", func(call goja.ConstructorCall) *goja.Object {
+		instance := &schema.SchemaField{}
+		return structConstructorUnmarshal(vm, call, instance)
+	})
+
+	vm.Set("MailerMessage", func(call goja.ConstructorCall) *goja.Object {
+		instance := &mailer.Message{}
+		return structConstructor(vm, call, instance)
+	})
+
+	vm.Set("Command", func(call goja.ConstructorCall) *goja.Object {
+		instance := &cobra.Command{}
+		return structConstructor(vm, call, instance)
+	})
+
+	vm.Set("RequestInfo", func(call goja.ConstructorCall) *goja.Object {
+		instance := &models.RequestInfo{}
+		return structConstructor(vm, call, instance)
+	})
+
+	vm.Set("DateTime", func(call goja.ConstructorCall) *goja.Object {
+		instance := types.NowDateTime()
+
+		val, _ := call.Argument(0).Export().(string)
+		if val != "" {
+			instance, _ = types.ParseDateTime(val)
+		}
+
+		instanceValue := vm.ToValue(instance).(*goja.Object)
+		instanceValue.SetPrototype(call.This.Prototype())
+
+		return structConstructor(vm, call, instance)
+	})
+
+	vm.Set("ValidationError", func(call goja.ConstructorCall) *goja.Object {
+		code, _ := call.Argument(0).Export().(string)
+		message, _ := call.Argument(1).Export().(string)
+
+		instance := validation.NewError(code, message)
+		instanceValue := vm.ToValue(instance).(*goja.Object)
+		instanceValue.SetPrototype(call.This.Prototype())
+
+		return instanceValue
+	})
+
+	vm.Set("Dao", func(call goja.ConstructorCall) *goja.Object {
+		concurrentDB, _ := call.Argument(0).Export().(dbx.Builder)
+		if concurrentDB == nil {
+			panic("[Dao] missing required Dao(concurrentDB, [nonconcurrentDB]) argument")
+		}
+
+		nonConcurrentDB, _ := call.Argument(1).Export().(dbx.Builder)
+		if nonConcurrentDB == nil {
+			nonConcurrentDB = concurrentDB
+		}
+
+		instance := daos.NewMultiDB(concurrentDB, nonConcurrentDB)
+		instanceValue := vm.ToValue(instance).(*goja.Object)
+		instanceValue.SetPrototype(call.This.Prototype())
+
+		return instanceValue
+	})
+
+	vm.Set("Cookie", func(call goja.ConstructorCall) *goja.Object {
+		instance := &http.Cookie{}
+		return structConstructor(vm, call, instance)
+	})
+
+	vm.Set("SubscriptionMessage", func(call goja.ConstructorCall) *goja.Object {
+		instance := &subscriptions.Message{}
+		return structConstructor(vm, call, instance)
+	})
+}
+
+func dbxBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$dbx", obj)
+
+	obj.Set("exp", dbx.NewExp)
+	obj.Set("hashExp", func(data map[string]any) dbx.HashExp {
+		return dbx.HashExp(data)
+	})
+	obj.Set("not", dbx.Not)
+	obj.Set("and", dbx.And)
+	obj.Set("or", dbx.Or)
+	obj.Set("in", dbx.In)
+	obj.Set("notIn", dbx.NotIn)
+	obj.Set("like", dbx.Like)
+	obj.Set("orLike", dbx.OrLike)
+	obj.Set("notLike", dbx.NotLike)
+	obj.Set("orNotLike", dbx.OrNotLike)
+	obj.Set("exists", dbx.Exists)
+	obj.Set("notExists", dbx.NotExists)
+	obj.Set("between", dbx.Between)
+	obj.Set("notBetween", dbx.NotBetween)
+}
+
+func mailsBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$mails", obj)
+
+	// admin
+	obj.Set("sendAdminPasswordReset", mails.SendAdminPasswordReset)
+
+	// record
+	obj.Set("sendRecordPasswordReset", mails.SendRecordPasswordReset)
+	obj.Set("sendRecordVerification", mails.SendRecordVerification)
+	obj.Set("sendRecordChangeEmail", mails.SendRecordChangeEmail)
+}
+
+func tokensBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$tokens", obj)
+
+	// admin
+	obj.Set("adminAuthToken", tokens.NewAdminAuthToken)
+	obj.Set("adminResetPasswordToken", tokens.NewAdminResetPasswordToken)
+	obj.Set("adminFileToken", tokens.NewAdminFileToken)
+
+	// record
+	obj.Set("recordAuthToken", tokens.NewRecordAuthToken)
+	obj.Set("recordVerifyToken", tokens.NewRecordVerifyToken)
+	obj.Set("recordResetPasswordToken", tokens.NewRecordResetPasswordToken)
+	obj.Set("recordChangeEmailToken", tokens.NewRecordChangeEmailToken)
+	obj.Set("recordFileToken", tokens.NewRecordFileToken)
+}
+
+func securityBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$security", obj)
+
+	// crypto
+	obj.Set("md5", security.MD5)
+	obj.Set("sha256", security.SHA256)
+	obj.Set("sha512", security.SHA512)
+	obj.Set("hs256", security.HS256)
+	obj.Set("hs512", security.HS512)
+	obj.Set("equal", security.Equal)
+
+	// random
+	obj.Set("randomString", security.RandomString)
+	obj.Set("randomStringWithAlphabet", security.RandomStringWithAlphabet)
+	obj.Set("pseudorandomString", security.PseudorandomString)
+	obj.Set("pseudorandomStringWithAlphabet", security.PseudorandomStringWithAlphabet)
+
+	// jwt
+	obj.Set("parseUnverifiedJWT", security.ParseUnverifiedJWT)
+	obj.Set("parseJWT", security.ParseJWT)
+	obj.Set("createJWT", security.NewJWT)
+
+	// encryption
+	obj.Set("encrypt", security.Encrypt)
+	obj.Set("decrypt", func(cipherText, key string) (string, error) {
+		result, err := security.Decrypt(cipherText, key)
+
+		if err != nil {
+			return "", err
+		}
+
+		return string(result), err
+	})
+}
+
+func filesystemBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$filesystem", obj)
+
+	obj.Set("fileFromPath", filesystem.NewFileFromPath)
+	obj.Set("fileFromBytes", filesystem.NewFileFromBytes)
+	obj.Set("fileFromMultipart", filesystem.NewFileFromMultipart)
+}
+
+func filepathBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$filepath", obj)
+
+	obj.Set("base", filepath.Base)
+	obj.Set("clean", filepath.Clean)
+	obj.Set("dir", filepath.Dir)
+	obj.Set("ext", filepath.Ext)
+	obj.Set("fromSlash", filepath.FromSlash)
+	obj.Set("glob", filepath.Glob)
+	obj.Set("isAbs", filepath.IsAbs)
+	obj.Set("join", filepath.Join)
+	obj.Set("match", filepath.Match)
+	obj.Set("rel", filepath.Rel)
+	obj.Set("split", filepath.Split)
+	obj.Set("splitList", filepath.SplitList)
+	obj.Set("toSlash", filepath.ToSlash)
+	obj.Set("walk", filepath.Walk)
+	obj.Set("walkDir", filepath.WalkDir)
+}
+
+func osBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$os", obj)
+
+	obj.Set("args", os.Args)
+	obj.Set("exec", exec.Command) // @deprecated
+	obj.Set("cmd", exec.Command)
+	obj.Set("exit", os.Exit)
+	obj.Set("getenv", os.Getenv)
+	obj.Set("dirFS", os.DirFS)
+	obj.Set("readFile", os.ReadFile)
+	obj.Set("writeFile", os.WriteFile)
+	obj.Set("readDir", os.ReadDir)
+	obj.Set("tempDir", os.TempDir)
+	obj.Set("truncate", os.Truncate)
+	obj.Set("getwd", os.Getwd)
+	obj.Set("mkdir", os.Mkdir)
+	obj.Set("mkdirAll", os.MkdirAll)
+	obj.Set("rename", os.Rename)
+	obj.Set("remove", os.Remove)
+	obj.Set("removeAll", os.RemoveAll)
+}
+
+func formsBinds(vm *goja.Runtime) {
+	registerFactoryAsConstructor(vm, "AdminLoginForm", forms.NewAdminLogin)
+	registerFactoryAsConstructor(vm, "AdminPasswordResetConfirmForm", forms.NewAdminPasswordResetConfirm)
+	registerFactoryAsConstructor(vm, "AdminPasswordResetRequestForm", forms.NewAdminPasswordResetRequest)
+	registerFactoryAsConstructor(vm, "AdminUpsertForm", forms.NewAdminUpsert)
+	registerFactoryAsConstructor(vm, "AppleClientSecretCreateForm", forms.NewAppleClientSecretCreate)
+	registerFactoryAsConstructor(vm, "CollectionUpsertForm", forms.NewCollectionUpsert)
+	registerFactoryAsConstructor(vm, "CollectionsImportForm", forms.NewCollectionsImport)
+	registerFactoryAsConstructor(vm, "RealtimeSubscribeForm", forms.NewRealtimeSubscribe)
+	registerFactoryAsConstructor(vm, "RecordEmailChangeConfirmForm", forms.NewRecordEmailChangeConfirm)
+	registerFactoryAsConstructor(vm, "RecordEmailChangeRequestForm", forms.NewRecordEmailChangeRequest)
+	registerFactoryAsConstructor(vm, "RecordOAuth2LoginForm", forms.NewRecordOAuth2Login)
+	registerFactoryAsConstructor(vm, "RecordPasswordLoginForm", forms.NewRecordPasswordLogin)
+	registerFactoryAsConstructor(vm, "RecordPasswordResetConfirmForm", forms.NewRecordPasswordResetConfirm)
+	registerFactoryAsConstructor(vm, "RecordPasswordResetRequestForm", forms.NewRecordPasswordResetRequest)
+	registerFactoryAsConstructor(vm, "RecordUpsertForm", forms.NewRecordUpsert)
+	registerFactoryAsConstructor(vm, "RecordVerificationConfirmForm", forms.NewRecordVerificationConfirm)
+	registerFactoryAsConstructor(vm, "RecordVerificationRequestForm", forms.NewRecordVerificationRequest)
+	registerFactoryAsConstructor(vm, "SettingsUpsertForm", forms.NewSettingsUpsert)
+	registerFactoryAsConstructor(vm, "TestEmailSendForm", forms.NewTestEmailSend)
+	registerFactoryAsConstructor(vm, "TestS3FilesystemForm", forms.NewTestS3Filesystem)
+}
+
+func apisBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$apis", obj)
+
+	obj.Set("staticDirectoryHandler", func(dir string, indexFallback bool) echo.HandlerFunc {
+		return apis.StaticDirectoryHandler(os.DirFS(dir), indexFallback)
+	})
+
+	// middlewares
+	obj.Set("requireRecordAuth", apis.RequireRecordAuth)
+	obj.Set("requireAdminAuth", apis.RequireAdminAuth)
+	obj.Set("requireAdminAuthOnlyIfAny", apis.RequireAdminAuthOnlyIfAny)
+	obj.Set("requireAdminOrRecordAuth", apis.RequireAdminOrRecordAuth)
+	obj.Set("requireAdminOrOwnerAuth", apis.RequireAdminOrOwnerAuth)
+	obj.Set("activityLogger", apis.ActivityLogger)
+
+	// record helpers
+	obj.Set("requestInfo", apis.RequestInfo)
+	obj.Set("recordAuthResponse", apis.RecordAuthResponse)
+	obj.Set("enrichRecord", apis.EnrichRecord)
+	obj.Set("enrichRecords", apis.EnrichRecords)
+
+	// api errors
+	registerFactoryAsConstructor(vm, "ApiError", apis.NewApiError)
+	registerFactoryAsConstructor(vm, "NotFoundError", apis.NewNotFoundError)
+	registerFactoryAsConstructor(vm, "BadRequestError", apis.NewBadRequestError)
+	registerFactoryAsConstructor(vm, "ForbiddenError", apis.NewForbiddenError)
+	registerFactoryAsConstructor(vm, "UnauthorizedError", apis.NewUnauthorizedError)
+}
+
+func httpClientBinds(vm *goja.Runtime) {
+	obj := vm.NewObject()
+	vm.Set("$http", obj)
+
+	type sendResult struct {
+		StatusCode int                     `json:"statusCode"`
+		Headers    map[string][]string     `json:"headers"`
+		Cookies    map[string]*http.Cookie `json:"cookies"`
+		Raw        string                  `json:"raw"`
+		Json       any                     `json:"json"`
+	}
+
+	type sendConfig struct {
+		Method  string
+		Url     string
+		Body    string
+		Headers map[string]string
+		Timeout int            // seconds (default to 120)
+		Data    map[string]any // deprecated, consider using Body instead
+	}
+
+	obj.Set("send", func(params map[string]any) (*sendResult, error) {
+		rawParams, err := json.Marshal(params)
+		if err != nil {
+			return nil, err
+		}
+
+		config := sendConfig{
+			Method: "GET",
+		}
+		if err := json.Unmarshal(rawParams, &config); err != nil {
+			return nil, err
+		}
+
+		if config.Timeout <= 0 {
+			config.Timeout = 120
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), time.Duration(config.Timeout)*time.Second)
+		defer cancel()
+
+		var reqBody io.Reader
+
+		// legacy json body data
+		if len(config.Data) != 0 {
+			encoded, err := json.Marshal(config.Data)
+			if err != nil {
+				return nil, err
+			}
+			reqBody = bytes.NewReader(encoded)
+		}
+
+		if config.Body != "" {
+			reqBody = strings.NewReader(config.Body)
+		}
+
+		req, err := http.NewRequestWithContext(ctx, strings.ToUpper(config.Method), config.Url, reqBody)
+		if err != nil {
+			return nil, err
+		}
+
+		for k, v := range config.Headers {
+			req.Header.Add(k, v)
+		}
+
+		// set default content-type header (if missing)
+		if req.Header.Get("content-type") == "" {
+			req.Header.Set("content-type", "application/json")
+		}
+
+		res, err := http.DefaultClient.Do(req)
+		if err != nil {
+			return nil, err
+		}
+		defer res.Body.Close()
+
+		bodyRaw, _ := io.ReadAll(res.Body)
+
+		result := &sendResult{
+			StatusCode: res.StatusCode,
+			Headers:    map[string][]string{},
+			Cookies:    map[string]*http.Cookie{},
+			Raw:        string(bodyRaw),
+		}
+
+		for k, v := range res.Header {
+			result.Headers[k] = v
+		}
+
+		for _, v := range res.Cookies() {
+			result.Cookies[v.Name] = v
+		}
+
+		if len(result.Raw) != 0 {
+			// try as map
+			result.Json = map[string]any{}
+			if err := json.Unmarshal(bodyRaw, &result.Json); err != nil {
+				// try as slice
+				result.Json = []any{}
+				if err := json.Unmarshal(bodyRaw, &result.Json); err != nil {
+					result.Json = nil
+				}
+			}
+		}
+
+		return result, nil
+	})
+}
+
+// -------------------------------------------------------------------
+
+// registerFactoryAsConstructor registers the factory function as native JS constructor.
+//
+// If there is missing or nil arguments, their type zero value is used.
+func registerFactoryAsConstructor(vm *goja.Runtime, constructorName string, factoryFunc any) {
+	rv := reflect.ValueOf(factoryFunc)
+	rt := reflect.TypeOf(factoryFunc)
+	totalArgs := rt.NumIn()
+
+	vm.Set(constructorName, func(call goja.ConstructorCall) *goja.Object {
+		args := make([]reflect.Value, totalArgs)
+
+		for i := 0; i < totalArgs; i++ {
+			v := call.Argument(i).Export()
+
+			// use the arg type zero value
+			if v == nil {
+				args[i] = reflect.New(rt.In(i)).Elem()
+			} else if number, ok := v.(int64); ok {
+				// goja uses int64 for "int"-like numbers but we rarely do that and use int most of the times
+				// (at later stage we can use reflection on the arguments to validate the types in case this is not sufficient anymore)
+				args[i] = reflect.ValueOf(int(number))
+			} else {
+				args[i] = reflect.ValueOf(v)
+			}
+		}
+
+		result := rv.Call(args)
+
+		if len(result) != 1 {
+			panic("the factory function should return only 1 item")
+		}
+
+		value := vm.ToValue(result[0].Interface()).(*goja.Object)
+		value.SetPrototype(call.This.Prototype())
+
+		return value
+	})
+}
+
+// structConstructor wraps the provided struct with a native JS constructor.
+//
+// If the constructor argument is a map, each entry of the map will be loaded into the wrapped goja.Object.
+func structConstructor(vm *goja.Runtime, call goja.ConstructorCall, instance any) *goja.Object {
+	data, _ := call.Argument(0).Export().(map[string]any)
+
+	instanceValue := vm.ToValue(instance).(*goja.Object)
+	for k, v := range data {
+		instanceValue.Set(k, v)
+	}
+
+	instanceValue.SetPrototype(call.This.Prototype())
+
+	return instanceValue
+}
+
+// structConstructorUnmarshal wraps the provided struct with a native JS constructor.
+//
+// The constructor first argument will be loaded via json.Unmarshal into the instance.
+func structConstructorUnmarshal(vm *goja.Runtime, call goja.ConstructorCall, instance any) *goja.Object {
+	if data := call.Argument(0).Export(); data != nil {
+		if raw, err := json.Marshal(data); err == nil {
+			json.Unmarshal(raw, instance)
+		}
+	}
+
+	instanceValue := vm.ToValue(instance).(*goja.Object)
+	instanceValue.SetPrototype(call.This.Prototype())
+
+	return instanceValue
+}
+
+// newDynamicModel creates a new dynamic struct with fields based
+// on the specified "shape".
+//
+// Example:
+//
+//	m := newDynamicModel(map[string]any{
+//		"title": "",
+//		"total": 0,
+//	})
+func newDynamicModel(shape map[string]any) any {
+	shapeValues := make([]reflect.Value, 0, len(shape))
+	structFields := make([]reflect.StructField, 0, len(shape))
+
+	for k, v := range shape {
+		vt := reflect.TypeOf(v)
+
+		switch kind := vt.Kind(); kind {
+		case reflect.Map:
+			raw, _ := json.Marshal(v)
+			newV := types.JsonMap{}
+			newV.Scan(raw)
+			v = newV
+			vt = reflect.TypeOf(v)
+		case reflect.Slice, reflect.Array:
+			raw, _ := json.Marshal(v)
+			newV := types.JsonArray[any]{}
+			newV.Scan(raw)
+			v = newV
+			vt = reflect.TypeOf(newV)
+		}
+
+		shapeValues = append(shapeValues, reflect.ValueOf(v))
+
+		structFields = append(structFields, reflect.StructField{
+			Name: inflector.UcFirst(k), // ensures that the field is exportable
+			Type: vt,
+			Tag:  reflect.StructTag(`db:"` + k + `" json:"` + k + `" form:"` + k + `"`),
+		})
+	}
+
+	st := reflect.StructOf(structFields)
+	elem := reflect.New(st).Elem()
+
+	for i, v := range shapeValues {
+		elem.Field(i).Set(v)
+	}
+
+	return elem.Addr().Interface()
+}

plugins/jsvm/internal/types/generated/embed.go

@@ -0,0 +1,6 @@
+package generated
+
+import "embed"
+
+//go:embed types.d.ts
+var Types embed.FS