From 99df7fe7302688846b78508127738137549cf7a3 Mon Sep 17 00:00:00 2001
From: Doug Bell <doug@preaction.me>
Date: Thu, 16 May 2019 17:51:41 -0500
Subject: [PATCH] rename "collection" to "schema"

The idea here is that "schema" is easier to say, but also in the future
where we put "schema" can be either the _name_ of a schema or an actual
schema (useful for Form plugins and Controllers).

This commit leaves all the tests largely as they were, triggering all
the deprecation warnings as a test. The next commit will remove all the
deprecation triggers in the tests, as well as make the deprecation
warnings slightly less annoying...

Refs #25
---
 lib/Mojolicious/Plugin/Yancy.pm               | 256 +++++++++---------
 .../Yancy/resources/public/yancy/app.js       | 113 ++++----
 .../yancy/auth/password/register.html.ep      |   2 +-
 .../resources/templates/yancy/index.html.ep   |  42 +--
 lib/Yancy.pm                                  |   2 +-
 lib/Yancy/Backend.pod                         |  60 ++--
 lib/Yancy/Backend/Dbic.pm                     |  85 +++---
 lib/Yancy/Backend/Mysql.pm                    |  16 +-
 lib/Yancy/Backend/Pg.pm                       |  16 +-
 lib/Yancy/Backend/Role/MojoAsync.pm           |  14 +-
 lib/Yancy/Backend/Role/Relational.pm          |  44 +--
 lib/Yancy/Backend/Sqlite.pm                   |  26 +-
 lib/Yancy/Controller/Yancy.pm                 | 108 ++++----
 lib/Yancy/Controller/Yancy/API.pm             |  82 +++---
 lib/Yancy/Controller/Yancy/MultiTenant.pm     |  39 +--
 lib/Yancy/Help/Config.pod                     | 106 ++++----
 lib/Yancy/Help/Standalone.pod                 |  10 +-
 lib/Yancy/Plugin/Auth.pm                      |  16 +-
 lib/Yancy/Plugin/Auth/Basic.pm                |  28 +-
 lib/Yancy/Plugin/Auth/Github.pm               |  22 +-
 lib/Yancy/Plugin/Auth/Password.pm             |  58 ++--
 lib/Yancy/Plugin/Auth/Token.pm                |  32 ++-
 lib/Yancy/Plugin/Form.pm                      |  14 +-
 lib/Yancy/Plugin/Form/Bootstrap4.pm           |   2 +-
 lib/Yancy/Util.pm                             |  16 +-
 t/api.t                                       |   9 +-
 t/backend/mock.t                              |   2 +-
 t/config.t                                    |  10 +-
 t/controller/multi_tenant.t                   |   8 +-
 t/controller/yancy.t                          |  29 +-
 t/filter.t                                    |  30 +-
 t/helpers.t                                   |  10 +-
 t/lib/Local/Test.pm                           |   8 +-
 t/lib/Yancy/Backend/Test.pm                   |  10 +-
 t/share/openapi-spec.json                     |   4 +-
 35 files changed, 704 insertions(+), 625 deletions(-)

diff --git a/lib/Mojolicious/Plugin/Yancy.pm b/lib/Mojolicious/Plugin/Yancy.pm
index eabcf8e2..6bd01af3 100644
--- a/lib/Mojolicious/Plugin/Yancy.pm
+++ b/lib/Mojolicious/Plugin/Yancy.pm
@@ -7,7 +7,7 @@ our $VERSION = '1.026';
     use Mojolicious::Lite;
     plugin Yancy => {
         backend => 'pg://postgres@/mydb',
-        collections => { ... },
+        schema => { ... },
     };
 
     ## With custom auth routine
@@ -21,7 +21,7 @@ our $VERSION = '1.026';
         } );
         $app->plugin( 'Yancy', {
             backend => 'pg://postgres@/mydb',
-            collections => { ... },
+            schema => { ... },
             route => $auth_route,
         });
     }
@@ -81,7 +81,7 @@ This plugin adds some helpers for use in routes, templates, and plugins.
     my $config = $c->yancy->config;
 
 The current configuration for Yancy. Through this, you can edit the
-C<collections> configuration as needed.
+C<schema> configuration as needed.
 
 =head2 yancy.backend
 
@@ -110,7 +110,7 @@ Yancy features and are found in the L<Yancy::Plugin> namespace.
 
     use Mojolicious::Lite;
     plugin 'Yancy';
-    app->yancy->plugin( 'Auth::Basic', { collection => 'users' } );
+    app->yancy->plugin( 'Auth::Basic', { schema => 'users' } );
 
 You can also add the Yancy::Plugin namespace into the default plugin
 lookup locations. This allows you to treat them like any other
@@ -135,9 +135,9 @@ Yancy does not do this for you to avoid namespace collisions.
 
 =head2 yancy.list
 
-    my @items = $c->yancy->list( $collection, \%param, \%opt );
+    my @items = $c->yancy->list( $schema, \%param, \%opt );
 
-Get a list of items from the backend. C<$collection> is a collection
+Get a list of items from the backend. C<$schema> is a schema
 name. C<\%param> is a L<SQL::Abstract where clause
 structure|SQL::Abstract/WHERE CLAUSES>. Some basic examples:
 
@@ -167,9 +167,9 @@ access the backend methods directly.
 
 =head2 yancy.get
 
-    my $item = $c->yancy->get( $collection, $id );
+    my $item = $c->yancy->get( $schema, $id );
 
-Get an item from the backend. C<$collection> is the collection name.
+Get an item from the backend. C<$schema> is the schema name.
 C<$id> is the ID of the item to get. See L<Yancy::Backend/get>.
 
 This helper will filter out password values in the returned data. To get
@@ -178,9 +178,9 @@ backend directly.
 
 =head2 yancy.set
 
-    $c->yancy->set( $collection, $id, $item_data, %opt );
+    $c->yancy->set( $schema, $id, $item_data, %opt );
 
-Update an item in the backend. C<$collection> is the collection name.
+Update an item in the backend. C<$schema> is the schema name.
 C<$id> is the ID of the item to update. C<$item_data> is a hash of data
 to update. See L<Yancy::Backend/set>. C<%opt> is a list of options with
 the following keys:
@@ -209,9 +209,9 @@ backend object directly via L<the backend helper|/yancy.backend>.
 
 =head2 yancy.create
 
-    my $item = $c->yancy->create( $collection, $item_data );
+    my $item = $c->yancy->create( $schema, $item_data );
 
-Create a new item. C<$collection> is the collection name. C<$item_data>
+Create a new item. C<$schema> is the schema name. C<$item_data>
 is a hash of data for the new item. See L<Yancy::Backend/create>.
 
 This helper will validate the data against the configuration and run any
@@ -232,17 +232,17 @@ backend object directly via L<the backend helper|/yancy.backend>.
 
 =head2 yancy.delete
 
-    $c->yancy->delete( $collection, $id );
+    $c->yancy->delete( $schema, $id );
 
-Delete an item from the backend. C<$collection> is the collection name.
+Delete an item from the backend. C<$schema> is the schema name.
 C<$id> is the ID of the item to delete. See L<Yancy::Backend/delete>.
 
 =head2 yancy.validate
 
-    my @errors = $c->yancy->validate( $collection, $item, %opt );
+    my @errors = $c->yancy->validate( $schema, $item, %opt );
 
 Validate the given C<$item> data against the configuration for the
-C<$collection>. If there are any errors, they are returned as an array
+C<$schema>. If there are any errors, they are returned as an array
 of L<JSON::Validator::Error> objects. C<%opt> is a list of options with
 the following keys:
 
@@ -271,11 +271,11 @@ at least three arguments:
 
 =over
 
-=item * $name - The name of the collection/field being filtered
+=item * $name - The name of the schema/field being filtered
 
 =item * $value - The value to filter, either the entire item, or a single field
 
-=item * $conf - The configuration for the collection/field
+=item * $conf - The configuration for the schema/field
 
 =item * @params - Other parameters if configured
 
@@ -296,7 +296,7 @@ And you configure this on a field using C<< x-filter >> and C<< x-digest >>:
 
     # mysite.conf
     {
-        collections => {
+        schema => {
             users => {
                 properties => {
                     username => { type => 'string' },
@@ -327,7 +327,7 @@ The alternative configuration:
 
     # mysite.conf
     {
-        collections => {
+        schema => {
             users => {
                 properties => {
                     username => { type => 'string' },
@@ -341,21 +341,21 @@ The alternative configuration:
         },
     }
 
-Collections can also have filters. A collection filter will get the
+Schemas can also have filters. A schema filter will get the
 entire hash reference as its value. For example, here's a filter that
 updates the C<last_updated> field with the current time:
 
     $c->yancy->filter->add( 'timestamp' => sub {
-        my ( $coll_name, $item, $coll_conf ) = @_;
+        my ( $schema_name, $item, $schema_conf ) = @_;
         $item->{last_updated} = time;
         return $item;
     } );
 
-And you configure this on the collection using C<< x-filter >>:
+And you configure this on the schema using C<< x-filter >>:
 
     # mysite.conf
     {
-        collections => {
+        schema => {
             people => {
                 'x-filter' => [ 'timestamp' ],
                 properties => {
@@ -368,7 +368,7 @@ And you configure this on the collection using C<< x-filter >>:
     }
 
 You can configure filters on OpenAPI operations' inputs. These will
-probably want to operate on hash-refs as in the collection-level filters
+probably want to operate on hash-refs as in the schema-level filters
 above. The config passed will be an empty hash. The filter can be applied
 to either or both of the path, or the individual operation, and will be
 executed in that order. E.g.:
@@ -431,7 +431,7 @@ This configuration will achieve the same as the above with C<last_updated>:
 
     # mysite.conf
     {
-        collections => {
+        schema => {
             people => {
                 properties => {
                     name => { type => 'string' },
@@ -463,7 +463,7 @@ This configuration will achieve the same as the above with C<last_updated>:
 
     # mysite.conf
     {
-        collections => {
+        schema => {
             people => {
                 'x-filter' => [
                     [ 'yancy.overlay_from_helper' => 'last_updated', 'current_time' ]
@@ -518,13 +518,13 @@ operates inside-outward.
 
 =head2 yancy.filter.apply
 
-    my $filtered_data = $c->yancy->filter->apply( $collection, $item_data );
+    my $filtered_data = $c->yancy->filter->apply( $schema, $item_data );
 
-Run the configured filters on the given C<$item_data>. C<$collection> is
-a collection name. Returns the hash of C<$filtered_data>.
+Run the configured filters on the given C<$item_data>. C<$schema> is
+a schema name. Returns the hash of C<$filtered_data>.
 
-The property-level filters will run before any collection-level filter,
-so that collection-level filters can take advantage of any values set by
+The property-level filters will run before any schema-level filter,
+so that schema-level filters can take advantage of any values set by
 the inner filters.
 
 =head2 yancy.filters
@@ -538,8 +538,8 @@ the code-refs.
     $c->yancy->schema( $name => $schema );
     my $schemas = $c->yancy->schema;
 
-Get or set the JSON schema for the given collection C<$name>. If no
-collection name is given, returns a hashref of all the collections.
+Get or set the JSON schema for the given schema C<$name>. If no
+schema name is given, returns a hashref of all the schema.
 
 =head2 yancy.openapi
 
@@ -605,7 +605,12 @@ sub register {
 
     # Create some safe copies of data structures we're about to mutate
     $config = { %$config };
-    $config->{collections} &&= dclone $config->{collections};
+    if ( my $schema = $config->{schema} || $config->{collections} ) {
+        $config->{schema} = dclone( $schema );
+    }
+    if ( $config->{collections} ) {
+        warn '"collection" config key is now "schema"';
+    }
 
     my $route = $config->{route} // $app->routes->any( '/yancy' );
     $route->to( return_to => $config->{return_to} // '/' );
@@ -623,7 +628,7 @@ sub register {
     $app->helper( 'yancy.config' => sub { return $config } );
     $app->helper( 'yancy.route' => sub { return $route } );
     $app->helper( 'yancy.backend' => sub {
-        state $backend = load_backend( $config->{backend}, $config->{collections} || $config->{openapi}{definitions} );
+        state $backend = load_backend( $config->{backend}, $config->{schema} || $config->{openapi}{definitions} );
     } );
 
     $app->helper( 'yancy.plugin' => \&_helper_plugin );
@@ -701,48 +706,49 @@ sub register {
             action => 'index',
         );
 
-    die "Cannot pass both openapi AND (collections or read_schema)"
+    die "Cannot pass both openapi AND (schema or read_schema)"
         if $config->{openapi}
-        and ( $config->{collections} or $config->{read_schema} );
+        and ( $config->{schema} or $config->{read_schema} );
 
     my $spec;
     if ( $config->{openapi} ) {
         $spec = $config->{openapi};
-        $config->{collections} = $spec->{definitions}; # for yancy.backend etc
+        $config->{schema} = $spec->{definitions}; # for yancy.backend etc
     }
     else {
         # Merge configuration
         if ( $config->{read_schema} ) {
             my $schema = $app->yancy->backend->read_schema;
             for my $c ( keys %$schema ) {
-                _merge_schema( $config->{collections}{ $c } ||= {}, $schema->{ $c } );
+                _merge_schema( $config->{schema}{ $c } ||= {}, $schema->{ $c } );
             }
-            # ; say 'Merged Config';
-            # ; use Data::Dumper;
-            # ; say Dumper $config;
         }
-        # read_schema on collections
-        for my $schema_name ( keys %{ $config->{collections} } ) {
-            my $schema = $config->{collections}{ $schema_name };
+        # read_schema on schema
+        for my $schema_name ( keys %{ $config->{schema} } ) {
+            my $schema = $config->{schema}{ $schema_name };
             if ( delete $schema->{read_schema} ) {
                 _merge_schema( $schema, $app->yancy->backend->read_schema( $schema_name ) );
             }
         }
 
+        # ; warn 'Merged Schema';
+        # ; use Data::Dumper;
+        # ; warn Dumper $config->{schema};
+
         # Sanity check for the schema.
-        for my $coll ( keys %{ $config->{collections} } ) {
-            my $schema = $config->{collections}{ $coll };
-            next if $schema->{ 'x-ignore' }; # XXX Should we just delete x-ignore collections?
+        for my $schema_name ( keys %{ $config->{schema} } ) {
+            my $schema = $config->{schema}{ $schema_name };
+            next if $schema->{ 'x-ignore' }; # XXX Should we just delete x-ignore schema?
             $schema->{ type } //= 'object';
-            my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+            my $real_schema_name = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
             my $props = $schema->{properties}
-                || $config->{collections}{ $real_coll }{properties};
+                || $config->{schema}{ $real_schema_name }{properties};
             my $id_field = $schema->{ 'x-id-field' } // 'id';
             if ( !$props->{ $id_field } ) {
-                die sprintf "ID field missing in properties for collection '%s', field '%s'."
+                die sprintf "ID field missing in properties for schema '%s', field '%s'."
                     . " Add x-id-field to configure the correct ID field name, or"
-                    . " add x-ignore to ignore this collection.",
-                        $coll, $id_field;
+                    . " add x-ignore to ignore this schema.",
+                        $schema_name, $id_field;
             }
         }
 
@@ -774,10 +780,10 @@ sub _ensure_json_data {
     decode_json $app->home->child( $data )->slurp;
 }
 
-sub _openapi_find_collection_name {
+sub _openapi_find_schema_name {
     my ( $self, $path, $pathspec ) = @_;
-    return $pathspec->{'x-collection'} if $pathspec->{'x-collection'};
-    my $collection;
+    return $pathspec->{'x-schema'} if $pathspec->{'x-schema'};
+    my $schema_name;
     for my $method ( grep !/^(parameters$|x-)/, keys %{ $pathspec } ) {
         my $op_spec = $pathspec->{ $method };
         my $schema;
@@ -799,15 +805,15 @@ sub _openapi_find_collection_name {
             ( $schema->{items} && $schema->{items}{'$ref'} ) ||
             ( $schema->{properties} && $schema->{properties}{items} && $schema->{properties}{items}{'$ref'} );
         next unless $this_ref =~ s:^#/definitions/::;
-        die "$method '$path' = $this_ref but also '$collection'"
-            if $this_ref and $collection and $this_ref ne $collection;
-        $collection = $this_ref;
+        die "$method '$path' = $this_ref but also '$schema_name'"
+            if $this_ref and $schema_name and $this_ref ne $schema_name;
+        $schema_name = $this_ref;
     }
-    if ( !$collection ) {
-        ($collection) = $path =~ m#^/([^/]+)#;
-        die "No collection found in '$path'" if !$collection;
+    if ( !$schema_name ) {
+        ($schema_name) = $path =~ m#^/([^/]+)#;
+        die "No schema found in '$path'" if !$schema_name;
     }
-    $collection;
+    $schema_name;
 }
 
 # mutates $spec
@@ -815,14 +821,14 @@ sub _openapi_spec_add_mojo {
     my ( $self, $spec, $config ) = @_;
     for my $path ( keys %{ $spec->{paths} } ) {
         my $pathspec = $spec->{paths}{ $path };
-        my $collection = $self->_openapi_find_collection_name( $path, $pathspec );
-        die "Path '$path' had non-existent collection '$collection'"
-            if !$spec->{definitions}{$collection};
+        my $schema = $self->_openapi_find_schema_name( $path, $pathspec );
+        die "Path '$path' had non-existent schema '$schema'"
+            if !$spec->{definitions}{$schema};
         for my $method ( grep !/^(parameters$|x-)/, keys %{ $pathspec } ) {
             my $op_spec = $pathspec->{ $method };
             my $mojo = $self->_openapi_spec_infer_mojo( $path, $pathspec, $method, $op_spec );
             $mojo->{controller} = $config->{api_controller};
-            $mojo->{collection} = $collection;
+            $mojo->{schema} = $schema;
             my @filters = (
                 @{ $pathspec->{ 'x-filter' } || [] },
                 @{ $op_spec->{ 'x-filter' } || [] },
@@ -859,7 +865,7 @@ sub _openapi_spec_infer_mojo {
             };
         }
         else {
-            # per-collection - GET = "list"
+            # per-schema - GET = "list"
             return {
                 action => 'list_items',
             };
@@ -910,23 +916,23 @@ sub _openapi_spec_from_schema {
             description => 'How to sort the list. A string containing one of "asc" (to sort in ascending order) or "desc" (to sort in descending order), followed by a ":", followed by the field name to sort by.',
         },
     );
-    for my $coll ( keys %{ $config->{collections} } ) {
+    for my $schema_name ( keys %{ $config->{schema} } ) {
         # Set some defaults so users don't have to type as much
-        my $schema = $config->{collections}{ $coll };
+        my $schema = $config->{schema}{ $schema_name };
         next if $schema->{ 'x-ignore' };
         my $id_field = $schema->{ 'x-id-field' } // 'id';
-        my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+        my $real_schema_name = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
         my $props = $schema->{properties}
-            || $config->{collections}{ $real_coll }{properties};
+            || $config->{schema}{ $real_schema_name }{properties};
         my %props = %$props;
 
-        $definitions{ $coll } = $schema;
+        $definitions{ $schema_name } = $schema;
 
         for my $prop ( keys %props ) {
             $props{ $prop }{ type } ||= 'string';
         }
 
-        $paths{ '/' . $coll } = {
+        $paths{ '/' . $schema_name } = {
             get => {
                 parameters => [
                     { '$ref' => '#/parameters/%24limit' },
@@ -954,7 +960,7 @@ sub _openapi_spec_from_schema {
                                 items => {
                                     type => 'array',
                                     description => 'This page of items',
-                                    items => { '$ref' => "#/definitions/" . url_escape $coll },
+                                    items => { '$ref' => "#/definitions/" . url_escape $schema_name },
                                 },
                             },
                         },
@@ -971,7 +977,7 @@ sub _openapi_spec_from_schema {
                         name => "newItem",
                         in => "body",
                         required => true,
-                        schema => { '$ref' => "#/definitions/" . url_escape $coll },
+                        schema => { '$ref' => "#/definitions/" . url_escape $schema_name },
                     },
                 ],
                 responses => {
@@ -979,7 +985,7 @@ sub _openapi_spec_from_schema {
                         description => "Entry was created",
                         schema => {
                             '$ref' => sprintf "#/definitions/%s/properties/%s",
-                                      map { url_escape $_ } $coll, $id_field,
+                                      map { url_escape $_ } $schema_name, $id_field,
                         },
                     },
                     default => {
@@ -990,7 +996,7 @@ sub _openapi_spec_from_schema {
             }),
         };
 
-        $paths{ sprintf '/%s/{%s}', $coll, $id_field } = {
+        $paths{ sprintf '/%s/{%s}', $schema_name, $id_field } = {
             parameters => [
                 {
                     name => $id_field,
@@ -1007,7 +1013,7 @@ sub _openapi_spec_from_schema {
                 responses => {
                     200 => {
                         description => "Item details",
-                        schema => { '$ref' => "#/definitions/" . url_escape $coll },
+                        schema => { '$ref' => "#/definitions/" . url_escape $schema_name },
                     },
                     default => {
                         description => "Unexpected error",
@@ -1023,13 +1029,13 @@ sub _openapi_spec_from_schema {
                         name => "newItem",
                         in => "body",
                         required => true,
-                        schema => { '$ref' => "#/definitions/" . url_escape $coll },
+                        schema => { '$ref' => "#/definitions/" . url_escape $schema_name },
                     }
                 ],
                 responses => {
                     200 => {
                         description => "Item was updated",
-                        schema => { '$ref' => "#/definitions/" . url_escape $coll },
+                        schema => { '$ref' => "#/definitions/" . url_escape $schema_name },
                     },
                     default => {
                         description => "Unexpected error",
@@ -1127,21 +1133,21 @@ sub _helper_plugin {
 sub _helper_schema {
     my ( $c, $name, $schema ) = @_;
     if ( !$name ) {
-        return $c->yancy->config->{collections};
+        return $c->yancy->config->{schema};
     }
     if ( $schema ) {
-        $c->yancy->config->{collections}{ $name } = $schema;
+        $c->yancy->config->{schema}{ $name } = $schema;
         return;
     }
-    return copy_inline_refs( $c->yancy->config->{collections}, "/$name" );
+    return copy_inline_refs( $c->yancy->config->{schema}, "/$name" );
 }
 
 sub _helper_list {
-    my ( $c, $coll_name, @args ) = @_;
-    my @items = @{ $c->yancy->backend->list( $coll_name, @args )->{items} };
-    my $coll = $c->yancy->schema( $coll_name );
-    for my $prop_name ( keys %{ $coll->{properties} } ) {
-        my $prop = $coll->{properties}{ $prop_name };
+    my ( $c, $schema_name, @args ) = @_;
+    my @items = @{ $c->yancy->backend->list( $schema_name, @args )->{items} };
+    my $schema = $c->yancy->schema( $schema_name );
+    for my $prop_name ( keys %{ $schema->{properties} } ) {
+        my $prop = $schema->{properties}{ $prop_name };
         if ( $prop->{format} && $prop->{format} eq 'password' ) {
             delete $_->{ $prop_name } for @items;
         }
@@ -1150,11 +1156,11 @@ sub _helper_list {
 }
 
 sub _helper_get {
-    my ( $c, $coll_name, $id, @args ) = @_;
-    my $item = $c->yancy->backend->get( $coll_name, $id, @args );
-    my $coll = $c->yancy->schema( $coll_name );
-    for my $prop_name ( keys %{ $coll->{properties} } ) {
-        my $prop = $coll->{properties}{ $prop_name };
+    my ( $c, $schema_name, $id, @args ) = @_;
+    my $item = $c->yancy->backend->get( $schema_name, $id, @args );
+    my $schema = $c->yancy->schema( $schema_name );
+    for my $prop_name ( keys %{ $schema->{properties} } ) {
+        my $prop = $schema->{properties}{ $prop_name };
         if ( $prop->{format} && $prop->{format} eq 'password' ) {
             delete $item->{ $prop_name };
         }
@@ -1168,25 +1174,25 @@ sub _helper_delete {
 }
 
 sub _helper_set {
-    my ( $c, $coll, $id, $item, %opt ) = @_;
+    my ( $c, $schema, $id, $item, %opt ) = @_;
     my %validate_opt =
         map { $_ => $opt{ $_ } }
         grep { exists $opt{ $_ } }
         qw( properties );
-    if ( my @errors = $c->yancy->validate( $coll, $item, %validate_opt ) ) {
+    if ( my @errors = $c->yancy->validate( $schema, $item, %validate_opt ) ) {
         $c->app->log->error(
-            sprintf 'Error validating item with ID "%s" in collection "%s": %s',
-            $id, $coll,
+            sprintf 'Error validating item with ID "%s" in schema "%s": %s',
+            $id, $schema,
             join ', ', map { sprintf '%s (%s)', $_->{message}, $_->{path} // '/' } @errors
         );
         die \@errors;
     }
-    $item = $c->yancy->filter->apply( $coll, $item );
-    my $ret = eval { $c->yancy->backend->set( $coll, $id, $item ) };
+    $item = $c->yancy->filter->apply( $schema, $item );
+    my $ret = eval { $c->yancy->backend->set( $schema, $id, $item ) };
     if ( $@ ) {
         $c->app->log->error(
-            sprintf 'Error setting item with ID "%s" in collection "%s": %s',
-            $id, $coll, $@,
+            sprintf 'Error setting item with ID "%s" in schema "%s": %s',
+            $id, $schema, $@,
         );
         die $@;
     }
@@ -1194,28 +1200,28 @@ sub _helper_set {
 }
 
 sub _helper_create {
-    my ( $c, $coll, $item ) = @_;
+    my ( $c, $schema, $item ) = @_;
 
-    my $props = $c->yancy->schema( $coll )->{properties};
+    my $props = $c->yancy->schema( $schema )->{properties};
     $item->{ $_ } = $props->{ $_ }{default}
         for grep !exists $item->{ $_ } && exists $props->{ $_ }{default},
         keys %$props;
 
-    if ( my @errors = $c->yancy->validate( $coll, $item ) ) {
+    if ( my @errors = $c->yancy->validate( $schema, $item ) ) {
         $c->app->log->error(
-            sprintf 'Error validating new item in collection "%s": %s',
-            $coll,
+            sprintf 'Error validating new item in schema "%s": %s',
+            $schema,
             join ', ', map { sprintf '%s (%s)', $_->{message}, $_->{path} // '/' } @errors
         );
         die \@errors;
     }
 
-    $item = $c->yancy->filter->apply( $coll, $item );
-    my $ret = eval { $c->yancy->backend->create( $coll, $item ) };
+    $item = $c->yancy->filter->apply( $schema, $item );
+    my $ret = eval { $c->yancy->backend->create( $schema, $item ) };
     if ( $@ ) {
         $c->app->log->error(
-            sprintf 'Error creating item in collection "%s": %s',
-            $coll, $@,
+            sprintf 'Error creating item in schema "%s": %s',
+            $schema, $@,
         );
         die $@;
     }
@@ -1223,10 +1229,10 @@ sub _helper_create {
 }
 
 sub _helper_validate {
-    my ( $c, $coll, $item, %opt ) = @_;
+    my ( $c, $schema_name, $item, %opt ) = @_;
     state $validator = {};
-    my $schema = $c->yancy->schema( $coll );
-    my $v = $validator->{ $coll } ||= _build_validator( $schema );
+    my $schema = $c->yancy->schema( $schema_name );
+    my $v = $validator->{ $schema } ||= _build_validator( $schema );
 
     my @args;
     if ( $opt{ properties } ) {
@@ -1272,28 +1278,28 @@ sub _helper_validate {
 }
 
 sub _helper_filter_apply {
-    my ( $self, $c, $coll_name, $item ) = @_;
-    my $coll = $c->yancy->schema( $coll_name );
+    my ( $self, $c, $schema_name, $item ) = @_;
+    my $schema = $c->yancy->schema( $schema_name );
     my $filters = $self->_filters;
-    for my $key ( keys %{ $coll->{properties} } ) {
-        next unless my $prop_filters = $coll->{properties}{ $key }{ 'x-filter' };
+    for my $key ( keys %{ $schema->{properties} } ) {
+        next unless my $prop_filters = $schema->{properties}{ $key }{ 'x-filter' };
         for my $filter ( @{ $prop_filters } ) {
             ( $filter, my @params ) = @$filter if ref $filter eq 'ARRAY';
             my $sub = $filters->{ $filter };
-            die "Unknown filter: $filter (collection: $coll_name, field: $key)"
+            die "Unknown filter: $filter (schema: $schema_name, field: $key)"
                 unless $sub;
             $item = { %$item, $key => $sub->(
-                $key, $item->{ $key }, $coll->{properties}{ $key }, @params
+                $key, $item->{ $key }, $schema->{properties}{ $key }, @params
             ) };
         }
     }
-    if ( my $coll_filters = $coll->{'x-filter'} ) {
-        for my $filter ( @{ $coll_filters } ) {
+    if ( my $schema_filters = $schema->{'x-filter'} ) {
+        for my $filter ( @{ $schema_filters } ) {
             ( $filter, my @params ) = @$filter if ref $filter eq 'ARRAY';
             my $sub = $filters->{ $filter };
-            die "Unknown filter: $filter (collection: $coll_name)"
+            die "Unknown filter: $filter (schema: $schema_name)"
                 unless $sub;
-            $item = $sub->( $coll_name, $item, $coll, @params );
+            $item = $sub->( $schema_name, $item, $schema, @params );
         }
     }
     return $item;
diff --git a/lib/Mojolicious/Plugin/Yancy/resources/public/yancy/app.js b/lib/Mojolicious/Plugin/Yancy/resources/public/yancy/app.js
index c0897eb0..2fbe5dac 100644
--- a/lib/Mojolicious/Plugin/Yancy/resources/public/yancy/app.js
+++ b/lib/Mojolicious/Plugin/Yancy/resources/public/yancy/app.js
@@ -225,9 +225,9 @@ var app = new Vue({
     data: function () {
         var current = this.parseHash();
         return {
-            hasCollections: null,
-            currentCollection: current.collection || null,
-            collections: {},
+            hasSchema: null,
+            currentSchemaName: current.schema || null,
+            schema: {},
             openedRow: null,
             deleteIndex: null,
             addingItem: false,
@@ -300,8 +300,8 @@ var app = new Vue({
             this.fetchPage();
         },
 
-        setCollection: function ( name ) {
-            this.currentCollection = name;
+        setSchema: function ( name ) {
+            this.currentSchemaName = name;
             $( '#sidebar-collapse' ).collapse('hide');
         },
 
@@ -316,9 +316,9 @@ var app = new Vue({
         },
 
         parseSpec: function ( spec ) {
-            var pathParts = [], collectionName, collection, pathObj, firstCollection;
-            this.collections = {};
-            this.hasCollections = false;
+            var pathParts = [], schemaName, schema, pathObj, firstSchema;
+            this.schema = {};
+            this.hasSchema = false;
 
             // Preprocess definitions
             for ( var defKey in spec.definitions ) {
@@ -372,74 +372,73 @@ var app = new Vue({
                 pathObj = spec.paths[ pathKey ];
 
                 pathParts = pathKey.split( '/' );
-                collectionName = pathParts[1];
+                schemaName = pathParts[1];
 
-                // Skip hidden collections
-                if ( spec.definitions[ collectionName ]['x-hidden'] ) {
+                // Skip hidden schemas
+                if ( spec.definitions[ schemaName ]['x-hidden'] ) {
                     continue;
                 }
 
-                collection = this.collections[ collectionName ];
-                if ( !collection ) {
-                    collection = this.collections[ collectionName ] = {
+                schema = this.schema[ schemaName ];
+                if ( !schema ) {
+                    schema = this.schema[ schemaName ] = {
                         operations: { }
                     };
                 }
-                if ( !firstCollection ) {
-                    firstCollection = collectionName;
+                if ( !firstSchema ) {
+                    firstSchema = schemaName;
                 }
-                this.hasCollections = true;
+                this.hasSchema = true;
 
                 // Array operations
                 if ( pathParts.length == 2 ) {
                     if ( pathObj.get ) {
-                        collection.operations["list"] = {
+                        schema.operations["list"] = {
                             url: [ spec.basePath, pathKey ].join(''),
-                            schema: spec.definitions[ collectionName ]
+                            schema: spec.definitions[ schemaName ]
                         };
                     }
                     if ( pathObj.post ) {
-                        collection.operations["add"] = {
+                        schema.operations["add"] = {
                             url: [ spec.basePath, pathKey ].join(''),
-                            schema: spec.definitions[ collectionName ]
+                            schema: spec.definitions[ schemaName ]
                         };
                     }
                 }
                 // Item operations
                 else {
                     if ( pathObj.get ) {
-                        collection.operations["get"] = {
+                        schema.operations["get"] = {
                             url: [ spec.basePath, pathKey ].join(''),
-                            schema: spec.definitions[ collectionName ]
+                            schema: spec.definitions[ schemaName ]
                         };
                     }
                     if ( pathObj.put ) {
-                        collection.operations["set"] = {
+                        schema.operations["set"] = {
                             url: [ spec.basePath, pathKey ].join(''),
-                            schema: spec.definitions[ collectionName ]
+                            schema: spec.definitions[ schemaName ]
                         };
                     }
                     if ( pathObj.delete ) {
-                        collection.operations["delete"] = {
+                        schema.operations["delete"] = {
                             url: [ spec.basePath, pathKey ].join(''),
-                            schema: spec.definitions[ collectionName ]
+                            schema: spec.definitions[ schemaName ]
                         };
                     }
                 }
             }
 
-            if ( this.currentCollection && this.collections[ this.currentCollection ] ) {
+            if ( this.currentSchemaName && this.schema[ this.currentSchemaName ] ) {
                 this.fetchPage();
             }
             else {
-                this.currentCollection = firstCollection;
+                this.currentSchemaName = firstSchema;
             }
         },
 
         fetchPage: function () {
             if ( this.fetching ) return;
-            var coll = this.collections[ this.currentCollection ],
-                self = this,
+            var self = this,
                 query = {
                     $limit: this.perPage,
                     $offset: this.perPage * ( this.currentPage - 1 )
@@ -455,7 +454,7 @@ var app = new Vue({
 
             this.fetching = true;
             delete this.error.fetchPage;
-            $.get( coll.operations["list"].url, query ).done(
+            $.get( this.currentOperations["list"].url, query ).done(
                 function ( data, status, jqXHR ) {
                     if ( query.offset > data.total ) {
                         // We somehow got to a page that doesn't exist,
@@ -468,7 +467,7 @@ var app = new Vue({
 
                     self.items = data.items;
                     self.total = data.total;
-                    self.columns = self.getListColumns( self.currentCollection ),
+                    self.columns = self.getListColumns( self.currentSchemaName ),
                     self.fetching = false;
                     self.updateHash();
                 }
@@ -479,9 +478,8 @@ var app = new Vue({
             );
         },
 
-        getListColumns: function ( collName ) {
-            var coll = this.collections[ collName ],
-                schema = coll.operations["list"].schema,
+        getListColumns: function ( schemaName ) {
+            var schema = this.schema[ schemaName ].operations["list"].schema,
                 props = schema.properties,
                 columns = schema['x-list-columns'] || [];
             return columns.map( function (c) {
@@ -494,23 +492,22 @@ var app = new Vue({
 
         parseHash: function () {
             var parts = location.hash.split( '/' ),
-                collection = parts[1],
+                schema = parts[1],
                 page = parts[2];
             return {
-                collection: collection,
+                schema: schema,
                 page: page
             };
         },
 
         updateHash: function () {
-            location.hash = "/" + this.currentCollection + "/" + this.currentPage;
+            location.hash = "/" + this.currentSchemaName + "/" + this.currentPage;
         },
 
         saveItem: function (i) {
             var self = this,
-                coll = this.collections[ this.currentCollection ],
-                value = this.prepareSaveItem( this.items[i], coll.operations['set'].schema ),
-                url = this.fillUrl( coll.operations['set'].url, this.openedOldValue );
+                value = this.prepareSaveItem( this.items[i], this.currentOperations['set'].schema ),
+                url = this.fillUrl( this.currentOperations['set'].url, this.openedOldValue );
             delete this.error.saveItem;
             this.$set( this, 'formError', {} );
             $.ajax(
@@ -541,9 +538,9 @@ var app = new Vue({
 
         addItem: function () {
             var self = this,
-                coll = this.collections[ this.currentCollection ],
-                value = this.prepareSaveItem( this.newItem, coll.operations['add'].schema ),
-                url = coll.operations['add'].url;
+                schema = this.currentSchema,
+                value = this.prepareSaveItem( this.newItem, schema ),
+                url = this.currentOperations['add'].url;
             delete this.error.addItem;
             this.$set( this, 'formError', {} );
             $.ajax(
@@ -555,13 +552,13 @@ var app = new Vue({
                 }
             ).done(
                 function ( data, status, jqXHR ) {
-                    var id = coll.operations['add'].schema['x-id-field'] || 'id';
+                    var id = self.currentOperations['add'].schema['x-id-field'] || 'id';
                     var urlParams = {};
                     urlParams[ id ] = data;
 
                     $.ajax(
                         {
-                            url: self.fillUrl( coll.operations['get'].url, urlParams ),
+                            url: self.fillUrl( self.currentOperations['get'].url, urlParams ),
                             method: 'GET',
                             dataType: 'json'
                         }
@@ -654,7 +651,7 @@ var app = new Vue({
         },
 
         createBlankItem: function () {
-            var schema = this.collections[ this.currentCollection ].operations['add'].schema,
+            var schema = this.currentSchema,
                 item = {};
             if ( schema.example ) {
                 return schema.example;
@@ -678,9 +675,9 @@ var app = new Vue({
         deleteItem: function () {
             var i = this.deleteIndex,
                 self = this,
-                coll = this.collections[ this.currentCollection ],
+                schema = this.currentSchema,
                 value = $( '#data-' + i ).val(),
-                url = this.fillUrl( coll.operations['delete'].url, this.items[i] );
+                url = this.fillUrl( this.currentOperations['delete'].url, this.items[i] );
             $.ajax(
                 {
                     url: url,
@@ -712,8 +709,8 @@ var app = new Vue({
         },
 
         renderValue: function ( field, value ) {
-            var coll = this.schema;
-            var fieldType = coll.properties[ field ].type;
+            var schema = this.currentSchema;
+            var fieldType = schema.properties[ field ].type;
             var type = Array.isArray( fieldType ) ? fieldType[0] : fieldType;
             if ( type == 'boolean' ) {
                 return value ? 'Yes' : 'No';
@@ -722,7 +719,7 @@ var app = new Vue({
         },
 
         rowViewUrl: function ( data ) {
-            return this.fillUrl( this.schema[ 'x-view-item-url' ], data );
+            return this.fillUrl( this.currentSchema[ 'x-view-item-url' ], data );
         },
 
         addToast: function ( toast ) {
@@ -766,15 +763,15 @@ var app = new Vue({
             return pages;
         },
 
-        operations: function () {
-            return this.collections[ this.currentCollection ] ? this.collections[ this.currentCollection ].operations : {};
+        currentOperations: function () {
+            return this.schema[ this.currentSchemaName ] ? this.schema[ this.currentSchemaName ].operations : {};
         },
-        schema: function () {
-            return this.operations.get ? this.operations.get.schema : {};
+        currentSchema: function () {
+            return this.currentOperations.get ? this.currentOperations.get.schema : {};
         }
     },
     watch: {
-        currentCollection: function () {
+        currentSchemaName: function () {
             this.data = [];
             this.currentPage = 1;
             this.openedRow = null;
diff --git a/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/auth/password/register.html.ep b/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/auth/password/register.html.ep
index fa61d4fc..76ecde6d 100644
--- a/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/auth/password/register.html.ep
+++ b/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/auth/password/register.html.ep
@@ -39,7 +39,7 @@
                         </div>
                     % }
                     % else {
-                        %= app->yancy->form->field_for( $plugin->collection, $field )
+                        %= app->yancy->form->field_for( $plugin->schema, $field )
                     % }
                 % }
                 <button class="btn btn-primary">Register</button>
diff --git a/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/index.html.ep b/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/index.html.ep
index 0bd44509..02f3af4a 100644
--- a/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/index.html.ep
+++ b/lib/Mojolicious/Plugin/Yancy/resources/templates/yancy/index.html.ep
@@ -169,7 +169,7 @@
 
 <main id="app" class="container-fluid">
 
-    <div v-if="hasCollections" class="sidebar col-sm-3 col-md-3 col-lg-2">
+    <div v-if="hasSchema" class="sidebar col-sm-3 col-md-3 col-lg-2">
         <div class="bg-dark p-2 justify-content-between sidebar-top">
             <button class="btn btn-outline-light" type="button"
                 data-toggle="collapse" data-target="#sidebar-collapse"
@@ -185,15 +185,15 @@
 
         <div id="sidebar-collapse" class="collapse">
             <h6 class="sidebar-heading text-muted px-3 mt-2">
-                Collections
+                Schema
             </h6>
 
             <ul class="nav flex-column">
-                <!-- collection list -->
-                <li v-for="( val, key ) in collections" class="nav-item">
-                    <a href="#" @click.prevent="setCollection( key )"
+                <!-- schema list -->
+                <li v-for="( val, key ) in schema" class="nav-item">
+                    <a href="#" @click.prevent="setSchema( key )"
                         class="nav-link"
-                        :class="currentCollection == key ? 'active' : ''"
+                        :class="currentSchema == key ? 'active' : ''"
                     >
                         {{ val.operations.list.schema.title || key }}
                     </a>
@@ -203,9 +203,9 @@
         </div>
     </div>
 
-    <div v-if="hasCollections !== null && !hasCollections" class="alert alert-danger" role="alert">
-        <h4 class="alert-heading">No Collections Configured</h4>
-        <p class="mb-0">Please configure your data collections, or have
+    <div v-if="hasSchema !== null && !hasSchema" class="alert alert-danger" role="alert">
+        <h4 class="alert-heading">No Schema Configured</h4>
+        <p class="mb-0">Please configure your data schema, or have
         Yancy scan your database by setting <code>read_schema =&gt;
         1</code>.</p>
     </div>
@@ -217,20 +217,20 @@
     </div>
 
     <div class="row">
-        <div v-show="currentCollection" class="offset-sm-3 col-sm-9 offset-md-3 col-md-9 offset-lg-2 col-lg-10 table-responsive-md">
-            <!-- current collection -->
-            <h2>{{ schema.title ? schema.title : currentCollection }}</h2>
-            <div v-if="schema.description"
-                v-html="marked( schema.description )"></div>
+        <div v-show="currentSchema" class="offset-sm-3 col-sm-9 offset-md-3 col-md-9 offset-lg-2 col-lg-10 table-responsive-md">
+            <!-- current schema -->
+            <h2>{{ currentSchema.title ? currentSchema.title : currentSchemaName }}</h2>
+            <div v-if="currentSchema.description"
+                v-html="marked( currentSchema.description )"></div>
 
             <div v-show="error && error.fetchPage" class="alert alert-danger" role="alert">
                 <h4 class="alert-heading">Error Fetching Data</h4>
                 <p class="mb-0">Error from server: {{ error.fetchPage }}</p>
             </div>
 
-            <div class="collection-buttons d-flex">
+            <div class="schema-buttons d-flex">
                 <button @click="fetchPage()" class="btn btn-primary mr-1">Refresh</button>
-                <a v-if="schema['x-view-url']" :href="schema['x-view-url']" class="btn btn-secondary mr-1">
+                <a v-if="currentSchema['x-view-url']" :href="currentSchema['x-view-url']" class="btn btn-secondary mr-1">
                     <i class="fa fa-eye" aria-hidden="true"></i> View
                 </a>
                 <button @click="newFilter = { }" class="btn btn-outline-secondary mr-1">
@@ -249,7 +249,7 @@
                     <p class="mb-0">Error from server: {{ error.addItem }}</p>
                 </div>
                 <item-form v-model="newItem"
-                    :schema="operations['add'].schema"
+                    :schema="currentOperations['add'].schema"
                     @close="cancelAddItem" @input="addItem"
                     :error="formError"
                     :show-read-only="false"
@@ -277,12 +277,12 @@
                 </div>
             </div>
 
-            <div v-show="columns && columns.length <= 1 && schema['x-list-columns-guessed']" class="alert alert-warning" role="alert">
+            <div v-show="columns && columns.length <= 1 && currentSchema['x-list-columns-guessed']" class="alert alert-warning" role="alert">
                 <h4 class="alert-heading">No Listable Columns Found</h4>
                 <p class="mb-0">Yancy was not able to guess what columns
                 to show in the list. Fix this (or silence this
                 message) by manually setting <code>x-list-columns</code>
-                for this collection.</p>
+                for this schema.</p>
             </div>
 
             <table style="margin-top: 0.5em; width: 100%" class="table data-table">
@@ -302,7 +302,7 @@
                     <template v-for="( row, i ) in items">
                     <tr :class="openedRow == i ? 'open' : ''">
                         <td style="width: 5em">
-                            <a v-if="schema['x-view-item-url']" :href="rowViewUrl(row)" title="View">
+                            <a v-if="currentSchema['x-view-item-url']" :href="rowViewUrl(row)" title="View">
                                 <i class="fa fa-eye" aria-hidden="true"></i>
                             </a>
                             <a href="#" @click.prevent="toggleRow(i)" title="Edit">
@@ -323,7 +323,7 @@
                                 <p class="mb-0">Error from server: {{ error.saveItem }}</p>
                             </div>
                             <item-form v-if="openedRow == i" v-model="items[i]"
-                                :schema="operations['set'].schema"
+                                :schema="currentOperations['set'].schema"
                                 @close="toggleRow(i)" @input="saveItem(i)"
                                 :error="formError"
                             />
diff --git a/lib/Yancy.pm b/lib/Yancy.pm
index bd722a68..e2377e48 100644
--- a/lib/Yancy.pm
+++ b/lib/Yancy.pm
@@ -102,7 +102,7 @@ L<OAuth2 authentication|Yancy::Plugin::Auth::OAuth2>.
 =item *
 
 L<The Form plugin|Yancy::Plugin::Form> can generate forms for the
-configured collections, or for individual fields. There are included
+configured schema, or for individual fields. There are included
 form generators for L<Bootstrap 4|Yancy::Plugin::Form::Bootstrap4>.
 
 =back
diff --git a/lib/Yancy/Backend.pod b/lib/Yancy/Backend.pod
index 424850f7..e212f2ec 100644
--- a/lib/Yancy/Backend.pod
+++ b/lib/Yancy/Backend.pod
@@ -5,14 +5,14 @@
 
     my $be = Yancy::Backend->new( $url );
 
-    $result = $be->list( $collection, $where, $options );
+    $result = $be->list( $schema, $where, $options );
     say "Total: " . $result->{total};
     say "Name: " . $_->{name} for @{ $result->{items} };
 
-    $item = $be->get( $collection, $id );
-    $be->set( $collection, $id, $item );
-    $be->delete( $collection, $id );
-    $id = $be->create( $collection, $item );
+    $item = $be->get( $schema, $id );
+    $be->set( $schema, $id, $item );
+    $be->delete( $schema, $id );
+    $id = $be->create( $schema, $item );
 
 =head1 DESCRIPTION
 
@@ -24,9 +24,9 @@ return values.
 
 =head2 Terminology
 
-Yancy backends work with collections, which are made up of items.
-A collection is a set of items, like a database table. An item is
-a single element of a collection, and must be a hashref.
+Yancy backends work with schemas, which are made up of items.
+A schema is a set of items, like a database table. An item is
+a single element of a schema, and must be a hashref.
 
 =head2 Asynchronous Backends
 
@@ -57,7 +57,7 @@ compatibility, but will not perform requests concurrently.
 =head2 new
 
     my $url = 'test://custom_string';
-    my $be = Yancy::Backend::Test->new( $url, $collections );
+    my $be = Yancy::Backend::Test->new( $url, $schema );
 
 Create a new backend object. C<$url> is a string that begins with the
 backend name followed by a colon. Everything else in the URL is for the
@@ -68,22 +68,22 @@ The backend name will be run through C<ucfirst> before being looked up
 in C<Yancy::Backend::>. For example, C<mysql://...> will use the
 L<Yancy::Backend::Mysql> module.
 
-C<$collections> is a hash reference of collection configuration from the
+C<$schema> is a hash reference of schema configuration from the
 Yancy configuration. Important configuration for the backend to support:
 
 =over
 
 =item x-id-field
 
-The name of the ID field for the collection. Defaults to C<id>. It does
+The name of the ID field for the schema. Defaults to C<id>. It does
 not need to be the primary key: This can be any unique identifier.
 
 =item properties
 
-Each collection is, at the very top, an array of hashrefs (a series of
-rows of column/value pairs). So, each collection should have
+Each schema is, at the very top, an array of hashrefs (a series of
+rows of column/value pairs). So, each schema should have
 a C<properties> key to declare what properties are available on the
-items in this collection.
+items in this schema.
 
 This is a hash reference with the keys as the field names and the values
 as hash references of configuration for the field. Some important
@@ -110,11 +110,11 @@ and the underlying database to do that.
 
 =head2 list
 
-    my $result = $be->list( $collection, $where, $opt );
+    my $result = $be->list( $schema, $where, $opt );
     # { total => ..., items => [ ... ] }
 
-Fetch a list of items from a collection. C<$collection> is the
-collection name.
+Fetch a list of items from a schema. C<$schema> is the
+schema name.
 
 C<$where> is a L<SQL::Abstract where structure|SQL::Abstract/WHERE
 CLAUSES>.
@@ -162,7 +162,7 @@ C<offset>.
 
 =head2 list_p
 
-    my $promise = $be->list_p( $collection, $where, $opt );
+    my $promise = $be->list_p( $schema, $where, $opt );
     $promise->then( sub {
         my ( $result ) = @_;
         # { total => ..., items => [ ... ] }
@@ -174,14 +174,14 @@ arguments and return values.
 
 =head2 get
 
-    my $item = $be->get( $collection, $id );
+    my $item = $be->get( $schema, $id );
 
-Get a single item. C<$collection> is the collection name. C<$id> is the
+Get a single item. C<$schema> is the schema name. C<$id> is the
 ID of the item to get. Returns a hashref of item data.
 
 =head2 get_p
 
-    my $promise = $be->get_p( $collection, $id );
+    my $promise = $be->get_p( $schema, $id );
     $promise->then( sub {
         my ( $item ) = @_;
         # ...
@@ -192,9 +192,9 @@ resolves to the item. See L</get> for arguments and return values.
 
 =head2 set
 
-    my $success = $be->set( $collection, $id, $item );
+    my $success = $be->set( $schema, $id, $item );
 
-Update an item. C<$collection> is the collection name. C<$id> is the ID
+Update an item. C<$schema> is the schema name. C<$id> is the ID
 of the item to update. C<$item> is the item's data to set. Returns
 a boolean that is true if a row with the given ID was found and updated,
 false otherwise.
@@ -204,7 +204,7 @@ scalars or JSON booleans.
 
 =head2 set_p
 
-    my $promise = $be->set_p( $collection, $id );
+    my $promise = $be->set_p( $schema, $id );
     $promise->then( sub {
         my ( $success ) = @_;
         # ...
@@ -216,9 +216,9 @@ L</set> for arguments and return values.
 
 =head2 create
 
-    my $id = $be->create( $collection, $item );
+    my $id = $be->create( $schema, $item );
 
-Create a new item. C<$collection> is the collection name.  C<$item> is
+Create a new item. C<$schema> is the schema name.  C<$item> is
 the item's data. Returns the ID of the row created suitable to be passed
 in to C<the get() method|/get>.
 
@@ -227,7 +227,7 @@ scalars or JSON booleans.
 
 =head2 create_p
 
-    my $promise = $be->create_p( $collection, $item );
+    my $promise = $be->create_p( $schema, $item );
     $promise->then( sub {
         my ( $id ) = @_;
         # ...
@@ -239,15 +239,15 @@ arguments and return values.
 
 =head2 delete
 
-    $be->delete( $collection, $id );
+    $be->delete( $schema, $id );
 
-Delete an item. C<$collection> is the collection name. C<$id> is the ID
+Delete an item. C<$schema> is the schema name. C<$id> is the ID
 of the item to delete. Returns a boolean that is true if a row with the
 given ID was found and deleted. False otherwise.
 
 =head2 delete_p
 
-    my $promise = $be->delete_p( $collection, $id );
+    my $promise = $be->delete_p( $schema, $id );
     $promise->then( sub {
         my ( $success ) = @_;
         # ...
diff --git a/lib/Yancy/Backend/Dbic.pm b/lib/Yancy/Backend/Dbic.pm
index ffb0c385..11d397ae 100644
--- a/lib/Yancy/Backend/Dbic.pm
+++ b/lib/Yancy/Backend/Dbic.pm
@@ -48,8 +48,7 @@ values.
 
 While reading the various sources, this method will check each source's
 C<result_class> for the existence of a C<yancy> method. If it exists,
-that will be called, and must return the starting-point of the JSON
-schema for that collection.
+that will be called, and must return the initial JSON schema for Yancy.
 
 A very useful possibility is for that JSON schema to just contain
 C<<{ 'x-ignore' => 1 }>>.
@@ -60,9 +59,9 @@ The URL for this backend takes the form C<< dbic://<schema_class>/<dbi_dsn> >>
 where C<schema_class> is the DBIx::Class schema module name and C<dbi_dsn> is
 the full L<DBI> data source name (DSN) used to connect to the database.
 
-=head2 Collections
+=head2 Schema Names
 
-The collections for this backend are the names of the
+The schema names for this backend are the names of the
 L<DBIx::Class::Row> classes in your schema, just as DBIx::Class allows
 in the C<< $schema->resultset >> method.
 
@@ -80,11 +79,11 @@ So, if you have the following schema:
     __PACKAGE__->table( 'business' );
     __PACKAGE__->add_columns( qw/ id name email / );
 
-You could map that schema to the following collections:
+You could map that to the following schema names:
 
     {
         backend => 'dbic://My::Schema/dbi:SQLite:test.db',
-        collections => {
+        schema => {
             People => {
                 properties => {
                     id => {
@@ -122,13 +121,19 @@ use Mojo::Loader qw( load_class );
 use Mojo::JSON qw( true encode_json );
 require Yancy::Backend::Role::Relational;
 
-has collections => ;
+has schema =>;
+sub collections {
+    require Carp;
+    Carp::carp( '"collections" method is now "schema"' );
+    shift->schema( @_ );
+}
+
 has dbic =>;
 
 *_normalize = \&Yancy::Backend::Role::Relational::normalize;
 
 sub new {
-    my ( $class, $backend, $collections ) = @_;
+    my ( $class, $backend, $schema ) = @_;
     if ( !ref $backend ) {
         my ( $dbic_class, $dsn, $optstr ) = $backend =~ m{^[^:]+://([^/]+)/([^?]+)(?:\?(.+))?$};
         if ( my $e = load_class( $dbic_class ) ) {
@@ -144,60 +149,60 @@ sub new {
         $backend = $dbic_class->connect( @$backend );
     }
     my %vars = (
-        collections => $collections,
+        schema => $schema,
         dbic => $backend,
     );
     return $class->SUPER::new( %vars );
 }
 
 sub _rs {
-    my ( $self, $coll, $params, $opt ) = @_;
+    my ( $self, $schema_name, $params, $opt ) = @_;
     $params ||= {}; $opt ||= {};
-    my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
-    my $rs = $self->dbic->resultset( $real_coll )->search( $params, $opt );
+    my $schema = $self->schema->{ $schema_name };
+    my $real_schema = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
+    my $rs = $self->dbic->resultset( $real_schema )->search( $params, $opt );
     $rs->result_class( 'DBIx::Class::ResultClass::HashRefInflator' );
     return $rs;
 }
 
 sub _find {
-    my ( $self, $coll, $id ) = @_;
-    my $id_field = $self->collections->{ $coll }{ 'x-id-field' } || 'id';
-    return $self->dbic->resultset( $coll )->find( { $id_field => $id } );
+    my ( $self, $schema_name, $id ) = @_;
+    my $id_field = $self->schema->{ $schema_name }{ 'x-id-field' } || 'id';
+    return $self->dbic->resultset( $schema_name )->find( { $id_field => $id } );
 }
 
 sub create {
-    my ( $self, $coll, $params ) = @_;
-    $params = $self->_normalize( $coll, $params );
-    die "No refs allowed in '$coll': " . encode_json $params
+    my ( $self, $schema_name, $params ) = @_;
+    $params = $self->_normalize( $schema_name, $params );
+    die "No refs allowed in '$schema_name': " . encode_json $params
         if grep ref, values %$params;
-    my $created = $self->dbic->resultset( $coll )->create( $params );
-    my $id_field = $self->collections->{ $coll }{ 'x-id-field' } || 'id';
+    my $created = $self->dbic->resultset( $schema_name )->create( $params );
+    my $id_field = $self->schema->{ $schema_name }{ 'x-id-field' } || 'id';
     return $created->$id_field;
 }
 
 sub get {
-    my ( $self, $coll, $id ) = @_;
-    my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my ( $self, $schema_name, $id ) = @_;
+    my $schema = $self->schema->{ $schema_name };
+    my $real_schema = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
     my $props = $schema->{properties}
-        || $self->collections->{ $real_coll }{properties};
+        || $self->schema->{ $real_schema }{properties};
     my $id_field = $schema->{ 'x-id-field' } || 'id';
     my $ret = $self->_rs(
-        $real_coll,
+        $real_schema,
         undef,
         { select => [ keys %$props ] },
     )->find( { $id_field => $id } );
-    return $self->_normalize( $coll, $ret );
+    return $self->_normalize( $schema_name, $ret );
 }
 
 sub list {
-    my ( $self, $coll, $params, $opt ) = @_;
+    my ( $self, $schema_name, $params, $opt ) = @_;
     $params ||= {}; $opt ||= {};
-    my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my $schema = $self->schema->{ $schema_name };
+    my $real_schema = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
     my $props = $schema->{properties}
-        || $self->collections->{ $real_coll }{properties};
+        || $self->schema->{ $real_schema }{properties};
     my %rs_opt = (
         order_by => $opt->{order_by},
         select => [ keys %$props ],
@@ -210,19 +215,19 @@ sub list {
         die "Offset must be number" if !looks_like_number $opt->{offset};
         $rs_opt{ offset } = $opt->{offset};
     }
-    my $rs = $self->_rs( $coll, $params, \%rs_opt );
+    my $rs = $self->_rs( $schema_name, $params, \%rs_opt );
     return {
-        items => [ map $self->_normalize( $coll, $_ ), $rs->all ],
-        total => $self->_rs( $coll, $params )->count,
+        items => [ map $self->_normalize( $schema_name, $_ ), $rs->all ],
+        total => $self->_rs( $schema_name, $params )->count,
     };
 }
 
 sub set {
-    my ( $self, $coll, $id, $params ) = @_;
-    $params = $self->_normalize( $coll, $params );
-    die "No refs allowed in '$coll'($id): " . encode_json $params
+    my ( $self, $schema_name, $id, $params ) = @_;
+    $params = $self->_normalize( $schema_name, $params );
+    die "No refs allowed in '$schema_name'($id): " . encode_json $params
         if grep ref, values %$params;
-    if ( my $row = $self->_find( $coll, $id ) ) {
+    if ( my $row = $self->_find( $schema_name, $id ) ) {
         $row->set_columns( $params );
         if ( $row->is_changed ) {
             $row->update;
@@ -233,10 +238,10 @@ sub set {
 }
 
 sub delete {
-    my ( $self, $coll, $id ) = @_;
+    my ( $self, $schema_name, $id ) = @_;
     # We assume that if we can find the row by ID, that the delete will
     # succeed
-    if ( my $row = $self->_find( $coll, $id ) ) {
+    if ( my $row = $self->_find( $schema_name, $id ) ) {
         $row->delete;
         return 1;
     }
diff --git a/lib/Yancy/Backend/Mysql.pm b/lib/Yancy/Backend/Mysql.pm
index 25367d22..d765b840 100644
--- a/lib/Yancy/Backend/Mysql.pm
+++ b/lib/Yancy/Backend/Mysql.pm
@@ -56,9 +56,9 @@ Some examples:
     # User+Pass Host and DB
     mysql://user:pass@example.com/mydb
 
-=head2 Collections
+=head2 Schema Names
 
-The collections for this backend are the names of the tables in the
+The schema names for this backend are the names of the tables in the
 database.
 
 So, if you have the following schema:
@@ -74,11 +74,11 @@ So, if you have the following schema:
         email VARCHAR(255) NULL
     );
 
-You could map that schema to the following collections:
+You could map that to the following schema:
 
     {
         backend => 'mysql://user@/mydb',
-        collections => {
+        schema => {
             People => {
                 required => [ 'name', 'email' ],
                 properties => {
@@ -139,7 +139,13 @@ our %IGNORE_TABLE = (
     dbix_class_schema_versions => 1,
 );
 
-has collections =>;
+has schema =>;
+sub collections {
+    require Carp;
+    Carp::carp( '"collections" method is now "schema"' );
+    shift->schema( @_ );
+}
+
 has mojodb =>;
 use constant mojodb_class => 'Mojo::mysql';
 use constant mojodb_prefix => 'mysql';
diff --git a/lib/Yancy/Backend/Pg.pm b/lib/Yancy/Backend/Pg.pm
index 5cdbd3cf..f02526a9 100644
--- a/lib/Yancy/Backend/Pg.pm
+++ b/lib/Yancy/Backend/Pg.pm
@@ -57,9 +57,9 @@ Some examples:
     # User+Pass Host and DB
     pg://user:pass@example.com/mydb
 
-=head2 Collections
+=head2 Schema Names
 
-The collections for this backend are the names of the tables in the
+The schema names for this backend are the names of the tables in the
 database.
 
 So, if you have the following schema:
@@ -75,11 +75,11 @@ So, if you have the following schema:
         email VARCHAR NULL
     );
 
-You could map that schema to the following collections:
+You could map that to the following schema:
 
     {
         backend => 'pg://user@/mydb',
-        collections => {
+        schema => {
             People => {
                 required => [ 'name', 'email' ],
                 properties => {
@@ -136,7 +136,13 @@ our %IGNORE_TABLE = (
     dbix_class_schema_versions => 1,
 );
 
-has collections =>;
+has schema =>;
+sub collections {
+    require Carp;
+    Carp::carp( '"collections" method is now "schema"' );
+    shift->schema( @_ );
+}
+
 has mojodb =>;
 use constant mojodb_class => 'Mojo::Pg';
 use constant mojodb_prefix => 'postgresql';
diff --git a/lib/Yancy/Backend/Role/MojoAsync.pm b/lib/Yancy/Backend/Role/MojoAsync.pm
index 7a1cceea..7ff3d87a 100644
--- a/lib/Yancy/Backend/Role/MojoAsync.pm
+++ b/lib/Yancy/Backend/Role/MojoAsync.pm
@@ -62,18 +62,18 @@ sub delete_p {
 }
 
 sub get_p {
-    my ( $self, $coll, $id ) = @_;
-    my $id_field = $self->id_field( $coll );
-    my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my ( $self, $schema_name, $id ) = @_;
+    my $id_field = $self->id_field( $schema_name );
+    my $schema = $self->schema->{ $schema_name };
+    my $real_schema_name = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
     my $props = $schema->{properties}
-        || $self->collections->{ $real_coll }{properties};
+        || $self->schema->{ $real_schema_name }{properties};
     my $db = $self->mojodb->db;
     return $db->select_p(
-        $real_coll,
+        $real_schema_name,
         [ keys %$props ],
         { $id_field => $id },
-    )->then( sub { $self->normalize( $coll, shift->hash ) } );
+    )->then( sub { $self->normalize( $schema_name, shift->hash ) } );
 }
 
 sub list_p {
diff --git a/lib/Yancy/Backend/Role/Relational.pm b/lib/Yancy/Backend/Role/Relational.pm
index 7b96db61..a64484f0 100644
--- a/lib/Yancy/Backend/Role/Relational.pm
+++ b/lib/Yancy/Backend/Role/Relational.pm
@@ -73,16 +73,16 @@ Self-explanatory, implements L<Yancy::Backend/new>.
 
 =head2 id_field
 
-Given a collection, returns the string name of its ID field.
+Given a schema, returns the string name of its ID field.
 
 =head2 list_sqls
 
-Given a collection, parameters and options, returns SQL to generate the
+Given a schema, parameters and options, returns SQL to generate the
 actual results, the count results, and the bind-parameters.
 
 =head2 normalize
 
-Given a collection and data, normalises any boolean values to 1 and 0.
+Given a schema and data, normalises any boolean values to 1 and 0.
 
 =head2 delete
 
@@ -181,7 +181,7 @@ requires qw(
 );
 
 sub new {
-    my ( $class, $backend, $collections ) = @_;
+    my ( $class, $backend, $schema ) = @_;
     if ( !ref $backend ) {
         my $found = (my $connect = $backend) =~ s#^.*?:##;
         $backend = $class->mojodb_class->new( $found ? $class->mojodb_prefix.":$connect" : () );
@@ -195,31 +195,31 @@ sub new {
     }
     my %vars = (
         mojodb => $backend,
-        collections => $collections,
+        schema => $schema,
     );
     Mojo::Base::new( $class, %vars );
 }
 
 sub id_field {
-    my ( $self, $coll ) = @_;
-    return $self->collections->{ $coll }{ 'x-id-field' } || 'id';
+    my ( $self, $schema ) = @_;
+    return $self->schema->{ $schema }{ 'x-id-field' } || 'id';
 }
 
 sub list_sqls {
-    my ( $self, $coll, $params, $opt ) = @_;
+    my ( $self, $schema_name, $params, $opt ) = @_;
     my $mojodb = $self->mojodb;
-    my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my $schema = $self->schema->{ $schema_name };
+    my $real_schema_name = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
     my $props = $schema->{properties}
-        || $self->collections->{ $real_coll }{properties};
+        || $self->schema->{ $real_schema_name }{properties};
     my ( $query, @params ) = $mojodb->abstract->select(
-        $real_coll,
+        $real_schema_name,
         [ keys %$props ],
         $params,
         $opt->{order_by},
     );
     my ( $total_query, @total_params ) = $mojodb->abstract->select(
-        $real_coll,
+        $real_schema_name,
         [ \'COUNT(*) as total' ],
         $params,
     );
@@ -236,9 +236,9 @@ sub list_sqls {
 }
 
 sub normalize {
-    my ( $self, $coll, $data ) = @_;
+    my ( $self, $schema_name, $data ) = @_;
     return undef if !$data;
-    my $schema = $self->collections->{ $coll }{ properties };
+    my $schema = $self->schema->{ $schema_name }{ properties };
     my %replace;
     for my $key ( keys %$data ) {
         next if !defined $data->{ $key }; # leave nulls alone
@@ -280,18 +280,18 @@ sub set {
 }
 
 sub get {
-    my ( $self, $coll, $id ) = @_;
-    my $id_field = $self->id_field( $coll );
-    my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my ( $self, $schema_name, $id ) = @_;
+    my $id_field = $self->id_field( $schema_name );
+    my $schema = $self->schema->{ $schema_name };
+    my $real_schema_name = ( $schema->{'x-view'} || {} )->{schema} // $schema_name;
     my $props = $schema->{properties}
-        || $self->collections->{ $real_coll }{properties};
+        || $self->schema->{ $real_schema_name }{properties};
     my $ret = $self->mojodb->db->select(
-        $real_coll,
+        $real_schema_name,
         [ keys %$props ],
         { $id_field => $id },
     )->hash;
-    return $self->normalize( $coll, $ret );
+    return $self->normalize( $schema_name, $ret );
 }
 
 sub list {
diff --git a/lib/Yancy/Backend/Sqlite.pm b/lib/Yancy/Backend/Sqlite.pm
index 7a50b050..ee641ad7 100644
--- a/lib/Yancy/Backend/Sqlite.pm
+++ b/lib/Yancy/Backend/Sqlite.pm
@@ -51,9 +51,9 @@ Some examples:
     # In a specific location
     sqlite:/tmp/filename.db
 
-=head2 Collections
+=head2 Schema Names
 
-The collections for this backend are the names of the tables in the
+The schema names for this backend are the names of the tables in the
 database.
 
 So, if you have the following schema:
@@ -69,11 +69,11 @@ So, if you have the following schema:
         email VARCHAR NULL
     );
 
-You could map that schema to the following collections:
+You could map that to the following schema:
 
     {
         backend => 'sqlite:filename.db',
-        collections => {
+        schema => {
             People => {
                 required => [ 'name', 'email' ],
                 properties => {
@@ -123,7 +123,13 @@ BEGIN {
         or die "Could not load SQLite backend: Mojo::SQLite version 3 or higher required\n";
 }
 
-has collections =>;
+has schema =>;
+sub collections {
+    require Carp;
+    Carp::carp( '"collections" method is now "schema"' );
+    shift->schema( @_ );
+}
+
 has mojodb =>;
 use constant mojodb_class => 'Mojo::SQLite';
 use constant mojodb_prefix => 'sqlite';
@@ -134,12 +140,12 @@ sub dbcatalog { undef }
 sub dbschema { undef }
 
 sub create {
-    my ( $self, $coll, $params ) = @_;
-    $params = $self->normalize( $coll, $params );
-    die "No refs allowed in '$coll': " . encode_json $params
+    my ( $self, $schema_name, $params ) = @_;
+    $params = $self->normalize( $schema_name, $params );
+    die "No refs allowed in '$schema_name': " . encode_json $params
         if grep ref, values %$params;
-    my $id_field = $self->id_field( $coll );
-    my $inserted_id = $self->mojodb->db->insert( $coll, $params )->last_insert_id;
+    my $id_field = $self->id_field( $schema_name );
+    my $inserted_id = $self->mojodb->db->insert( $schema_name, $params )->last_insert_id;
     # SQLite does not have a 'returning' syntax. Assume id field is correct
     # if passed, created otherwise:
     return $params->{$id_field} || $inserted_id;
diff --git a/lib/Yancy/Controller/Yancy.pm b/lib/Yancy/Controller/Yancy.pm
index 61a1126b..7611c8b4 100644
--- a/lib/Yancy/Controller/Yancy.pm
+++ b/lib/Yancy/Controller/Yancy.pm
@@ -6,7 +6,7 @@ our $VERSION = '1.026';
 
     use Mojolicious::Lite;
     plugin Yancy => {
-        collections => {
+        schema => {
             blog => {
                 properties => {
                     id => { type => 'integer' },
@@ -19,7 +19,7 @@ our $VERSION = '1.026';
 
     app->routes->get( '/' )->to(
         'yancy#list',
-        collection => 'blog',
+        schema => 'blog',
         template => 'index',
     );
 
@@ -33,7 +33,7 @@ our $VERSION = '1.026';
 =head1 DESCRIPTION
 
 This controller contains basic route handlers for displaying content
-configured in Yancy collections. These route handlers reduce the amount
+configured in Yancy schema. These route handlers reduce the amount
 of code you need to write to display or modify your content.
 
 Route handlers use the Mojolicious C<stash> for configuration. These values
@@ -108,7 +108,7 @@ use Mojo::Base 'Mojolicious::Controller';
 
     $routes->get( '/' )->to(
         'yancy#list',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
 
@@ -118,9 +118,9 @@ This method uses the following stash values for configuration:
 
 =over
 
-=item collection
+=item schema
 
-The collection to use. Required.
+The schema to use. Required.
 
 =item template
 
@@ -161,8 +161,11 @@ The number of pages of items. Can be used for pagination.
 
 sub list {
     my ( $c ) = @_;
-    my $coll_name = $c->stash( 'collection' )
-        || die "Collection name not defined in stash";
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' )
+        || die "Schema name not defined in stash";
     my $limit = $c->stash->{ limit } //= 10;
     my $page = $c->stash->{ page } //= 1;
     my $offset = ( $page - 1 ) * $limit;
@@ -173,7 +176,7 @@ sub list {
     my $filter = {
         %{ $c->stash( 'filter' ) || {} },
     };
-    my $items = $c->yancy->backend->list( $coll_name, $filter, $opt );
+    my $items = $c->yancy->backend->list( $schema_name, $filter, $opt );
     return $c->respond_to(
         json => sub {
             $c->stash( json => { %$items, offset => $offset } );
@@ -191,7 +194,7 @@ sub list {
 
     $routes->get( '/:id' )->to(
         'yancy#get',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
 
@@ -201,13 +204,13 @@ This method uses the following stash values for configuration:
 
 =over
 
-=item collection
+=item schema
 
-The collection to use. Required.
+The schema to use. Required.
 
 =item id
 
-The ID of the item from the collection. Required. Usually part of
+The ID of the item from the schema. Required. Usually part of
 the route path as a placeholder.
 
 =item template
@@ -231,10 +234,13 @@ The item that is being displayed.
 
 sub get {
     my ( $c ) = @_;
-    my $coll_name = $c->stash( 'collection' )
-        || die "Collection name not defined in stash";
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' )
+        || die "Schema name not defined in stash";
     my $id = $c->stash( 'id' ) // die 'ID not defined in stash';
-    my $item = $c->yancy->backend->get( $coll_name => $id );
+    my $item = $c->yancy->backend->get( $schema_name => $id );
     if ( !$item ) {
         $c->reply->not_found;
         return;
@@ -249,23 +255,23 @@ sub get {
 
     $routes->any( [ 'GET', 'POST' ] => '/:id/edit' )->to(
         'yancy#set',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
 
     $routes->any( [ 'GET', 'POST' ] => '/create' )->to(
         'yancy#set',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
         forward_to => $route_name,
     );
 
 This route creates a new item or updates an existing item in
-a collection. If the user is making a C<GET> request, they will simply
+a schema. If the user is making a C<GET> request, they will simply
 be shown the template. If the user is making a C<POST> or C<PUT>
 request, the form parameters will be read, the data will be validated
-against L<the collection configuration|Yancy::Help::Config/Data
-Collections>, and the user will either be shown the form again with the
+against L<the schema configuration|Yancy::Help::Config/Data
+Schema>, and the user will either be shown the form again with the
 result of the form submission (success or failure) or the user will be
 forwarded to another place.
 
@@ -273,13 +279,13 @@ This method uses the following stash values for configuration:
 
 =over
 
-=item collection
+=item schema
 
-The collection to use. Required.
+The schema to use. Required.
 
 =item id
 
-The ID of the item from the collection. Optional: If not specified, a new
+The ID of the item from the schema. Optional: If not specified, a new
 item will be created. Usually part of the route path as a placeholder.
 
 =item template
@@ -295,7 +301,7 @@ route placeholders that match item field names will be filled in.
     $routes->get( '/:id/:slug' )->name( 'blog.view' );
     $routes->post( '/create' )->to(
         'yancy#set',
-        collection => 'blog',
+        schema => 'blog',
         template => 'blog_edit.html.ep',
         forward_to => 'blog.view',
     );
@@ -313,7 +319,7 @@ will result in an error.
 
 B<NOTE:> Unless restricted to certain properties using this
 configuration, this method accepts all valid data configured for the
-collection. The data being submitted can be more than just the fields
+schema. The data being submitted can be more than just the fields
 you make available in the form. If you do not want certain data to be
 written through this form, you can prevent it by using this.
 
@@ -358,12 +364,12 @@ method, but with more code:
 
     $routes->get( '/:id/edit' )->to(
         'yancy#get',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
     $routes->post( '/:id/edit' )->to(
         'yancy#set',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
 
@@ -371,8 +377,11 @@ method, but with more code:
 
 sub set {
     my ( $c ) = @_;
-    my $coll_name = $c->stash( 'collection' )
-        || die "Collection name not defined in stash";
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' )
+        || die "Schema name not defined in stash";
     my $id = $c->stash( 'id' );
 
     # Display the form, if requested. This makes the simple case of
@@ -380,9 +389,9 @@ sub set {
     # of two routes (one to "yancy#get" and one to "yancy#set")
     if ( $c->req->method eq 'GET' ) {
         if ( $id ) {
-            my $item = $c->yancy->get( $coll_name => $id );
+            my $item = $c->yancy->get( $schema_name => $id );
             $c->stash( item => $item );
-            my $props = $c->yancy->schema( $coll_name )->{properties};
+            my $props = $c->yancy->schema( $schema_name )->{properties};
             for my $key ( keys %$props ) {
                 # Mojolicious TagHelpers take current values through the
                 # params, but also we allow pre-filling values through the
@@ -413,7 +422,7 @@ sub set {
         $c->app->log->error( 'CSRF token validation failed' );
         $c->render(
             status => 400,
-            item => $c->yancy->get( $coll_name => $id ),
+            item => $c->yancy->get( $schema_name => $id ),
             errors => [
                 {
                     message => 'CSRF token invalid.',
@@ -428,7 +437,7 @@ sub set {
     #; use Data::Dumper;
     #; $c->app->log->debug( Dumper $data );
 
-    my $props = $c->yancy->schema( $coll_name )->{properties};
+    my $props = $c->yancy->schema( $schema_name )->{properties};
     for my $key ( keys %$props ) {
         my $format = $props->{ $key }{ format };
         # Password cannot be changed to an empty string
@@ -448,10 +457,10 @@ sub set {
 
     my $update = $id ? 1 : 0;
     if ( $update ) {
-        eval { $c->yancy->set( $coll_name, $id, $data, %opt ) };
+        eval { $c->yancy->set( $schema_name, $id, $data, %opt ) };
     }
     else {
-        $id = eval { $c->yancy->create( $coll_name, $data ) };
+        $id = eval { $c->yancy->create( $schema_name, $data ) };
     }
 
     if ( my $errors = $@ ) {
@@ -464,7 +473,7 @@ sub set {
             $c->res->code( 500 );
             $errors = [ { message => $errors } ];
         }
-        my $item = $c->yancy->get( $coll_name, $id );
+        my $item = $c->yancy->get( $schema_name, $id );
         $c->respond_to(
             json => { json => { errors => $errors } },
             html => { item => $item, errors => $errors },
@@ -472,7 +481,7 @@ sub set {
         return;
     }
 
-    my $item = $c->yancy->get( $coll_name, $id );
+    my $item = $c->yancy->get( $schema_name, $id );
     return $c->respond_to(
         json => sub {
             $c->stash(
@@ -494,12 +503,12 @@ sub set {
 
     $routes->any( [ 'GET', 'POST' ], '/delete/:id' )->to(
         'yancy#delete',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
         forward_to => $route_name,
     );
 
-This route deletes an item from a collection. If the user is making
+This route deletes an item from a schema. If the user is making
 a C<GET> request, they will simply be shown the template (which can be
 used to confirm the delete). If the user is making a C<POST> or C<DELETE>
 request, the item will be deleted and the user will either be shown the
@@ -510,13 +519,13 @@ This method uses the following stash values for configuration:
 
 =over
 
-=item collection
+=item schema
 
-The collection to use. Required.
+The schema to use. Required.
 
 =item id
 
-The ID of the item from the collection. Required. Usually part of the
+The ID of the item from the schema. Required. Usually part of the
 route path as a placeholder.
 
 =item template
@@ -554,14 +563,17 @@ L<Mojolicious::Guides::Rendering/Cross-site request forgery>.
 
 sub delete {
     my ( $c ) = @_;
-    my $coll_name = $c->stash( 'collection' )
-        || die "Collection name not defined in stash";
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' )
+        || die "Schema name not defined in stash";
     my $id = $c->stash( 'id' ) // die 'ID not defined in stash';
 
     # Display the form, if requested. This makes it easy to display
     # a confirmation page in a single route.
     if ( $c->req->method eq 'GET' ) {
-        my $item = $c->yancy->get( $coll_name => $id );
+        my $item = $c->yancy->get( $schema_name => $id );
         $c->respond_to(
             json => {
                 status => 400,
@@ -582,7 +594,7 @@ sub delete {
         $c->app->log->error( 'CSRF token validation failed' );
         $c->render(
             status => 400,
-            item => $c->yancy->get( $coll_name => $id ),
+            item => $c->yancy->get( $schema_name => $id ),
             errors => [
                 {
                     message => 'CSRF token invalid.',
@@ -592,7 +604,7 @@ sub delete {
         return;
     }
 
-    $c->yancy->delete( $coll_name, $id );
+    $c->yancy->delete( $schema_name, $id );
 
     return $c->respond_to(
         json => sub {
diff --git a/lib/Yancy/Controller/Yancy/API.pm b/lib/Yancy/Controller/Yancy/API.pm
index c9fa02c3..28b9ab40 100644
--- a/lib/Yancy/Controller/Yancy/API.pm
+++ b/lib/Yancy/Controller/Yancy/API.pm
@@ -18,7 +18,7 @@ and override the desired methods to provide the desired functionality.
     sub list_items {
         my ( $c ) = @_;
         return unless $c->openapi->valid_input;
-        my $items = $c->yancy->backend->list( $c->stash( 'collection' ) );
+        my $items = $c->yancy->backend->list( $c->stash( 'schema' ) );
         return $c->render(
             status => 200,
             openapi => $items,
@@ -46,8 +46,8 @@ use Mojo::JSON qw( to_json );
 
 =method list_items
 
-List the items in a collection. The collection name should be in the
-stash key C<collection>.
+List the items in a schema. The schema name should be in the
+stash key C<schema>.
 
 Each returned item will be filtered by filters conforming with
 L<Mojolicious::Plugin::Yancy/yancy.filter.add> that are passed in the
@@ -75,8 +75,11 @@ sub list_items {
     }
 
     my %filter;
-    my $coll = $c->stash( 'collection' );
-    my $schema = $c->yancy->schema( $coll )  ;
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' );
+    my $schema = $c->yancy->schema( $schema_name )  ;
     my $props  = $schema->{properties};
     for my $key ( keys %$args ) {
         my $value = $args->{ $key };
@@ -100,10 +103,10 @@ sub list_items {
         }
     }
 
-    my $res = $c->yancy->backend->list( $coll, \%filter, \%opt );
+    my $res = $c->yancy->backend->list( $schema_name, \%filter, \%opt );
     _delete_null_values( @{ $res->{items} } );
     $res->{items} = [
-        map _apply_op_filters( $coll, $_, $c->stash( 'filters_out' ), $c->yancy->filters ), @{ $res->{items} }
+        map _apply_op_filters( $schema_name, $_, $c->stash( 'filters_out' ), $c->yancy->filters ), @{ $res->{items} }
     ] if $c->stash( 'filters_out' );
 
     return $c->render(
@@ -122,14 +125,14 @@ sub _is_type {
 
 =method add_item
 
-Add a new item to the collection. The collection name should be in the
-stash key C<collection>.
+Add a new item to the schema. The schema name should be in the
+stash key C<schema>.
 
 The new item is extracted from the OpenAPI input, under parameter name
 C<newItem>, and must be a hash/JSON "object". It will be filtered by
 filters conforming with L<Mojolicious::Plugin::Yancy/yancy.filter.add>
 that are passed in the array-ref in stash key C<filters>, after the
-collection and property filters have been applied.
+schema and property filters have been applied.
 
 The return value is filtered like each result is in L</list_items>.
 
@@ -138,12 +141,15 @@ The return value is filtered like each result is in L</list_items>.
 sub add_item {
     my ( $c ) = @_;
     return unless $c->openapi->valid_input;
-    my $coll = $c->stash( 'collection' );
-    my $item = $c->yancy->filter->apply( $coll, $c->validation->param( 'newItem' ) );
-    $item = _apply_op_filters( $coll, $item, $c->stash( 'filters' ), $c->yancy->filters )
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' );
+    my $item = $c->yancy->filter->apply( $schema_name, $c->validation->param( 'newItem' ) );
+    $item = _apply_op_filters( $schema_name, $item, $c->stash( 'filters' ), $c->yancy->filters )
         if $c->stash( 'filters' );
-    my $res = $c->yancy->backend->create( $coll, $item );
-    $res = _apply_op_filters( $coll, $res, $c->stash( 'filters_out' ), $c->yancy->filters )
+    my $res = $c->yancy->backend->create( $schema_name, $item );
+    $res = _apply_op_filters( $schema_name, $res, $c->stash( 'filters_out' ), $c->yancy->filters )
         if $c->stash( 'filters_out' );
     return $c->render(
         status => 201,
@@ -153,8 +159,8 @@ sub add_item {
 
 =method get_item
 
-Get a single item from a collection. The collection should be in the
-stash key C<collection>.
+Get a single item from a schema. The schema should be in the stash key
+C<schema>.
 
 The item's ID field-name is in the stash key C<id_field>. The ID itself
 is extracted from the OpenAPI input, under a parameter of that name.
@@ -168,9 +174,12 @@ sub get_item {
     return unless $c->openapi->valid_input;
     my $args = $c->validation->output;
     my $id = $args->{ $c->stash( 'id_field' ) };
-    my $coll = $c->stash( 'collection' );
-    my $res = _delete_null_values( $c->yancy->backend->get( $coll, $id ) );
-    $res = _apply_op_filters( $coll, $res, $c->stash( 'filters_out' ), $c->yancy->filters )
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' );
+    my $res = _delete_null_values( $c->yancy->backend->get( $schema_name, $id ) );
+    $res = _apply_op_filters( $schema_name, $res, $c->stash( 'filters_out' ), $c->yancy->filters )
         if $c->stash( 'filters_out' );
     return $c->render(
         status => 200,
@@ -180,8 +189,8 @@ sub get_item {
 
 =method set_item
 
-Update an item in a collection. The collection should be in the stash
-key C<collection>.
+Update an item in a schema. The schema should be in the stash key
+C<schema>.
 
 The item to be updated is determined as with L</get_item>, and what to
 update it with is determined as with L</add_item>.
@@ -195,17 +204,20 @@ sub set_item {
     return unless $c->openapi->valid_input;
     my $args = $c->validation->output;
     my $id = $args->{ $c->stash( 'id_field' ) };
-    my $coll = $c->stash( 'collection' );
-    my $item = $c->yancy->filter->apply( $coll, $args->{ newItem } );
-    $item = _apply_op_filters( $coll, $item, $c->stash( 'filters' ), $c->yancy->filters )
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' );
+    my $item = $c->yancy->filter->apply( $schema_name, $args->{ newItem } );
+    $item = _apply_op_filters( $schema_name, $item, $c->stash( 'filters' ), $c->yancy->filters )
         if $c->stash( 'filters' );
-    $c->yancy->backend->set( $coll, $id, $item );
+    $c->yancy->backend->set( $schema_name, $id, $item );
 
     # ID field may have changed
     $id = $item->{ $c->stash( 'id_field' ) } || $id;
 
-    my $res = _delete_null_values( $c->yancy->backend->get( $coll, $id ) );
-    $res = _apply_op_filters( $coll, $res, $c->stash( 'filters_out' ), $c->yancy->filters )
+    my $res = _delete_null_values( $c->yancy->backend->get( $schema_name, $id ) );
+    $res = _apply_op_filters( $schema_name, $res, $c->stash( 'filters_out' ), $c->yancy->filters )
         if $c->stash( 'filters_out' );
     return $c->render(
         status => 200,
@@ -215,8 +227,8 @@ sub set_item {
 
 =method delete_item
 
-Delete an item from a collection. The collection name should be in the
-stash key C<collection>.
+Delete an item from a schema. The schema name should be in the
+stash key C<schema>.
 
 The item to be deleted is determined as with L</get_item>.
 
@@ -227,7 +239,11 @@ sub delete_item {
     return unless $c->openapi->valid_input;
     my $args = $c->validation->output;
     my $id = $args->{ $c->stash( 'id_field' ) };
-    $c->yancy->backend->delete( $c->stash( 'collection' ), $id );
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' );
+    $c->yancy->backend->delete( $schema_name, $id );
     return $c->rendered( 204 );
 }
 
@@ -252,13 +268,13 @@ sub _delete_null_values {
 # Similar to the helper 'yancy.filter.apply' - filters input item,
 # returns updated version.
 sub _apply_op_filters {
-    my ( $coll, $item, $filters, $app_filters ) = @_;
+    my ( $schema_name, $item, $filters, $app_filters ) = @_;
     $item = { %$item }; # no mutate input
     for my $filter ( @$filters ) {
         ( $filter, my @params ) = @$filter if ref $filter eq 'ARRAY';
         my $sub = $app_filters->{ $filter };
         die "Unknown filter: $filter" unless $sub;
-        $item = $sub->( $coll, $item, {}, @params );
+        $item = $sub->( $schema_name, $item, {}, @params );
     }
     $item;
 }
diff --git a/lib/Yancy/Controller/Yancy/MultiTenant.pm b/lib/Yancy/Controller/Yancy/MultiTenant.pm
index 19221b66..41f51275 100644
--- a/lib/Yancy/Controller/Yancy/MultiTenant.pm
+++ b/lib/Yancy/Controller/Yancy/MultiTenant.pm
@@ -6,7 +6,7 @@ our $VERSION = '1.026';
 
     use Mojolicious::Lite;
     plugin Yancy => {
-        collections => {
+        schema => {
             blog => {
                 properties => {
                     id => { type => 'integer' },
@@ -20,7 +20,7 @@ our $VERSION = '1.026';
 
     app->routes->get( '/user/:user_id' )->to(
         'yancy-multi_tenant#list',
-        collection => 'blog',
+        schema => 'blog',
         template => 'index'
     );
 
@@ -60,13 +60,13 @@ in the path to the ID:
     # /:username - List blog posts
     $user_route->get( '' )->to(
         'yancy-multi_tenant#list',
-        collection => 'blog',
+        schema => 'blog',
         template => 'blog_list',
     );
     # /:username/:id/:slug - Get a single blog post
     $user_route->get( '/:id/:slug' )->to(
         'yancy-multi_tenant#get',
-        collection => 'blog',
+        schema => 'blog',
         template => 'blog_view',
     );
 
@@ -77,7 +77,7 @@ C<user_id> from the current user.
 
     app->yancy->plugin( 'Auth::Basic', {
         route => any( '' ), # All routes require login
-        collection => 'user',
+        schema => 'user',
         username_field => 'username',
         password_digest => { type => 'SHA-1' },
     } );
@@ -92,7 +92,7 @@ C<user_id> from the current user.
     # / - List todo items
     $user_route->get( '' )->to(
         'yancy-multi_tenant#list',
-        collection => 'todo_item',
+        schema => 'todo_item',
         template => 'todo_list',
     );
 
@@ -108,7 +108,7 @@ use Mojo::Base 'Yancy::Controller::Yancy';
 
     $routes->get( '/:user_id' )->to(
         'yancy-multi_tenant#list',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
 
@@ -147,7 +147,7 @@ sub list {
 
     $routes->get( '/:user_id/:id' )->to(
         'yancy-multi_tenant#get',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
 
@@ -182,22 +182,22 @@ sub get {
 
     $routes->any( [ 'GET', 'POST' ] => '/:id/edit' )->to(
         'yancy#set',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
     );
 
     $routes->any( [ 'GET', 'POST' ] => '/create' )->to(
         'yancy#set',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
         forward_to => $route_name,
     );
 
 This route creates a new item or updates an existing item in
-a collection. If the user is making a C<GET> request, they will simply
+a schema. If the user is making a C<GET> request, they will simply
 be shown the template. If the user is making a C<POST> or C<PUT>
 request, the form parameters will be read, the data will be validated
-against L<the collection configuration|Yancy::Help::Config/Data
+against L<the schema configuration|Yancy::Help::Config/Data
 Collections>, and the user will either be shown the form again with the
 result of the form submission (success or failure) or the user will be
 forwarded to another place.
@@ -244,12 +244,12 @@ sub set {
 
     $routes->any( [ 'GET', 'POST' ], '/delete/:id' )->to(
         'yancy#delete',
-        collection => $collection_name,
+        schema => $schema_name,
         template => $template_name,
         forward_to => $route_name,
     );
 
-This route deletes an item from a collection. If the user is making
+This route deletes an item from a schema. If the user is making
 a C<GET> request, they will simply be shown the template (which can be
 used to confirm the delete). If the user is making a C<POST> or C<DELETE>
 request, the item will be deleted and the user will either be shown the
@@ -290,17 +290,20 @@ sub delete {
 #   return if !_is_owned_by();
 #
 # Check that the currently-requested item is owned by the user_id in the
-# stash. This uses the collection, id, user_id, and user_id_field stash
+# stash. This uses the schema, id, user_id, and user_id_field stash
 # values. user_id_field defaults to 'user_id'. All other fields are
 # required and will throw an exception if missing.
 sub _is_owned_by {
     my ( $c ) = @_;
-    my $coll_name = $c->stash( 'collection' )
-        || die "Collection name not defined in stash";
+    if ( $c->stash( 'collection' ) ) {
+        warn '"collection" stash key is now "schema"';
+    }
+    my $schema_name = $c->stash( 'schema' ) || $c->stash( 'collection' )
+        || die "Schema name not defined in stash";
     my $user_id = $c->stash( 'user_id' ) || die "User ID not defined in stash";
     my $id = $c->stash( 'id' ) // die 'ID not defined in stash';
     my $user_id_field = $c->stash( 'user_id_field' ) // 'user_id';
-    my $item = $c->yancy->backend->get( $coll_name => $id );
+    my $item = $c->yancy->backend->get( $schema_name => $id );
     if ( !$item || $item->{ $user_id_field } ne $user_id ) {
         $c->reply->not_found;
         return 0;
diff --git a/lib/Yancy/Help/Config.pod b/lib/Yancy/Help/Config.pod
index 48374dfe..b842016e 100644
--- a/lib/Yancy/Help/Config.pod
+++ b/lib/Yancy/Help/Config.pod
@@ -7,7 +7,7 @@
     plugin Yancy => {
         backend => 'pg://localhost/myapp',
         read_schema => 1,
-        collections => {
+        schema => {
             users => {
                 title => 'Users',
                 description => 'The authorized user accounts',
@@ -96,14 +96,14 @@ below. See your backend's documentation for more information.
 
 =head1 Data Collections
 
-The C<collections> data structure defines what data is in the database.
-Each key in this structure refers to the name of a collection, and the
-value describe the fields for items inside the collection.
+The C<schema> data structure defines what data is in the database.
+Each key in this structure refers to the name of a schema, and the
+value describe the fields for items inside the schema.
 
-Each backend may define a collection differently. For a relational
-database like Postgres or MySQL, a collection is a table, and the fields
-are columns. For an ORM like DBIx::Class, the collections are ResultSet
-objects. For a document store like MongoDB, the collections are
+Each backend may define a schema differently. For a relational
+database like Postgres or MySQL, a schema is a table, and the fields
+are columns. For an ORM like DBIx::Class, the schemas are ResultSet
+objects. For a document store like MongoDB, the schemas are
 collections. See your backend's documentation for more information.
 
 Collections are configured using L<JSON Schema|http://json-schema.org>.
@@ -114,11 +114,11 @@ expressions. The schema can also contain metadata like a C<title>,
 C<description>, and even an C<example> value. For more information on
 what can be defined, see L<the docs on JSON Schema|http://json-schema.org>.
 
-For a collection named C<people> that has 3 fields (an integer C<id> and
+For a schema named C<people> that has 3 fields (an integer C<id> and
 two strings, C<name> and C<email>), a minimal JSON schema will look like
 this:
 
-    collections => {
+    schema => {
         people => {
             properties => {
                 id => {
@@ -135,8 +135,8 @@ this:
         },
     },
 
-Instead of (or in addition to) defining collections yourself, you can
-tell Yancy to read your database to try to determine your collection
+Instead of (or in addition to) defining schema yourself, you can
+tell Yancy to read your database to try to determine your schema
 configuration. See L<read_schema|/read_schema> for more information.
 
 =head2 Types
@@ -210,7 +210,7 @@ input fields:
 JSON Schema allows marking properties as required using the C<required>
 property, which must be an array of property names.
 
-    collections => {
+    schema => {
         people => {
             required => [ 'name', 'email' ],
             properties => {
@@ -236,7 +236,7 @@ If a value can be C<null> (C<undef> in Perl terms) in addition to its
 declared type (C<string>, C<integer>, etc...), you must add it to the
 C<type> field by using an array of types:
 
-    collections => {
+    schema => {
         people => {
             required => [ 'name' ],
             properties => {
@@ -262,8 +262,8 @@ this error is to add C<null> as an option for the field's type.
 
 Setting an example value makes it easier to add new data. When a user
 tries to add a new item, Yancy will fill in the data from the C<example>
-key of the collection. This key holds an example object using fake data.
-As an example of our C<people> collection:
+key of the schema. This key holds an example object using fake data.
+As an example of our C<people> schema:
 
     people => {
         example => {
@@ -275,26 +275,26 @@ As an example of our C<people> collection:
 
 =head2 Extended Collection Configuration
 
-There are some extended fields you can add to your collection definition
+There are some extended fields you can add to your schema definition
 to control how it is treated by Yancy.
 
 =over
 
 =item title
 
-A friendly title for the collection
+A friendly title for the schema
 
 =item description
 
-A description of the collection. Markdown will be parsed into HTML.
+A description of the schema. Markdown will be parsed into HTML.
 
 You can use the C<trim> and C<unindent> functions from L<Mojo::Util> to
-allow indenting your collection description:
+allow indenting your schema description:
 
     use Mojolicious::Lite;
     use Mojo::Util qw( unindent trim );
     plugin Yancy => {
-        collections => {
+        schema => {
             employees => {
                 description => unindent( trim q{
                     The employees of Planet Express.
@@ -308,22 +308,22 @@ allow indenting your collection description:
 
 =item x-hidden
 
-If this is true, the collection will be hidden from the list in the Yancy
+If this is true, the schema will be hidden from the list in the Yancy
 web app. This does not prevent using the API to edit this data.
 
 =item x-ignore
 
-Ignore this collection: Do not add it to the API, do not show it in the
-rich editing form. This is for collections that should not be edited
+Ignore this schema: Do not add it to the API, do not show it in the
+rich editing form. This is for schema that should not be edited
 from the Yancy form or the Yancy API.
 
-This allows for removing collections when using L</read_schema>.
+This allows for removing schema when using L</read_schema>.
 
 =item x-id-field
 
-This key sets the name of the collection's ID field to use to uniquely
+This key sets the name of the schema's ID field to use to uniquely
 identify individual items. By default, Yancy assumes the ID field is
-named C<id>. If your collection uses some other identifier (e-mail
+named C<id>. If your schema uses some other identifier (e-mail
 address or username for example), you should set this configuration key.
 
     people => {
@@ -369,12 +369,12 @@ code-ref as parameters after the mandatory three.
 
 =item x-view-url
 
-A URL to view the collection in the application. Will be shown as a button
+A URL to view the schema in the application. Will be shown as a button
 in the editor.
 
 =item x-view-item-url
 
-A URL to view the items in the collection. Will be shown as an icon next to
+A URL to view the items in the schema. Will be shown as an icon next to
 the item row. Add data from the row in the url using C<{field}>, like so:
 
     # /people/1
@@ -402,7 +402,7 @@ A description of the field. Markdown will be parsed into HTML.
 =item x-hidden
 
 If true, thie field will be hidden from the rich editing form. This is
-for collections that you want to use from the API but do not want to
+for schema that you want to use from the API but do not want to
 edit from the Yancy application.
 
 =item x-order
@@ -430,31 +430,31 @@ code-ref as parameters after the mandatory three.
     # to get a data-light "view" of users when listing comments end of blogpost
     usermini => {
         type => 'object',
-        'x-view' => { collection => 'user' },
+        'x-view' => { schema => 'user' },
         properties => {
             id => { 'x-order' => 1, type => 'integer' },
             username => { 'x-order' => 2, type => 'string' },
         },
     },
 
-This key means the collection is not a real one that exists in the
+This key means the schema is not a real one that exists in the
 backend, but a strict subset of a real one. It is an object with keys:
 
 =over
 
-=item collection
+=item schema
 
-Mandatory. Names the "real" collection. B<NB> This is the collection's
+Mandatory. Names the "real" schema. B<NB> This is the schema's
 text name, not a JSON pointer.
 
 =back
 
 All the properties' types will need to be the same as on the "real"
 one since the datasource will be the real one. If no properties are given,
-the "real" collection's ones will be used.
+the "real" schema's ones will be used.
 
 The generated OpenAPI spec will only have read functionality for the
-"view" collection, not mutations.
+"view" schema, not mutations.
 
 =back
 
@@ -462,13 +462,13 @@ The generated OpenAPI spec will only have read functionality for the
 
 =head2 Generation
 
-An OpenAPI spec will be generated from the C<collections> specified as
-above, by using the C<collections> value as the C</definitions> of the
+An OpenAPI spec will be generated from the C<schema> specified as
+above, by using the C<schema> value as the C</definitions> of the
 spec. A default type called C<_Error> will be added, to act as the
 return type in case of error.
 
 From this, the C</paths> will be generated by adding one for each of CRUD
-(create, read, update, delete) plus a "list", to each collection.
+(create, read, update, delete) plus a "list", to each schema.
 
 Finally, for each operation generated under C</paths>, an C<x-mojo-to>
 will be added, to connect it to the right controller. See
@@ -476,25 +476,25 @@ L<Mojolicious::Plugin::OpenAPI::Guides::Tutorial> for more information.
 
 =head2 Passing in complete
 
-As an alternative to supplying only the C<collections> (and/or a true
+As an alternative to supplying only the C<schema> (and/or a true
 value for C<read_schema>), you can pass a complete OpenAPI spec as
-C<openapi>. It is an error to pass both C<collections> and C<openapi>. The
+C<openapi>. It is an error to pass both C<schema> and C<openapi>. The
 spec will then have C<x-mojo-to> added to each operation, using inferences
 based on the HTTP method.
 
-The C</definitions> of the spec will be used as the C<collections>
+The C</definitions> of the spec will be used as the C<schema>
 property of the L<backend|Yancy::Backend>.
 
 All of the operations on each path under C</paths> of the spec must,
-in line with REST convention, refer to only a single "collection". If
-any path has operations referring to more than one collection, that is
-an error. To derive which collection, these things are considered:
+in line with REST convention, refer to only a single "schema". If
+any path has operations referring to more than one schema, that is
+an error. To derive which schema, these things are considered:
 
 =over
 
 =item *
 
-a key C<x-collection> with string-value under the path
+a key C<x-schema> with string-value under the path
 
 =item *
 
@@ -548,15 +548,15 @@ There are additional configuration keys to alter how Yancy works.
 
 =head2 C<read_schema>
 
-When this is set, Yancy will read your backend to see what collections
-you have available. Any collections and fields that you do not configure
+When this is set, Yancy will read your backend to see what schema
+you have available. Any schema and fields that you do not configure
 will be assigned default configuration from your database schema. You
 can use the configuration to override information that Yancy gets
 incorrect, or to set information that Yancy can't (like the C<title> and
-C<description> of collections and properties).
+C<description> of schema and properties).
 
-You can also set this on a per-collection basis to read only certain
-collections from the database. This way you can include only the data
+You can also set this on a per-schema basis to read only certain
+schema from the database. This way you can include only the data
 you want in your editor.
 
 B<NOTE:> This exposes all the data in your schema to Yancy's API, which allows
@@ -564,7 +564,7 @@ anyone to edit the data. If you do not want anyone to edit the data, use
 L<the plugin's route configuration|Mojolicious::Plugin::Yancy/CONFIGURATION> to
 add authentication to Yancy.
 
-    # All collections
+    # All schemas
     use Mojolicious::Lite;
     plugin Yancy => {
         backend => 'pg://localhost/myapp',
@@ -575,7 +575,7 @@ add authentication to Yancy.
     use Mojolicious::Lite;
     plugin Yancy => {
         backend => 'pg://localhost/myapp',
-        collections => {
+        schema => {
             notes => { read_schema => 1 },
             events => { read_schema => 1 },
         },
diff --git a/lib/Yancy/Help/Standalone.pod b/lib/Yancy/Help/Standalone.pod
index 45e23926..b0f86483 100644
--- a/lib/Yancy/Help/Standalone.pod
+++ b/lib/Yancy/Help/Standalone.pod
@@ -68,15 +68,15 @@ provides.
 
 =over
 
-=item * C<< yancy->list( $collection ) >> - Get a list of items
+=item * C<< yancy->list( $schema ) >> - Get a list of items
 
-=item * C<< yancy->get( $collection, $id ) >> - Get a single item
+=item * C<< yancy->get( $schema, $id ) >> - Get a single item
 
-=item * C<< yancy->set( $collection, $id, $data ) >> - Update an item
+=item * C<< yancy->set( $schema, $id, $data ) >> - Update an item
 
-=item * C<< yancy->delete( $collection, $id ) >> - Delete an item
+=item * C<< yancy->delete( $schema, $id ) >> - Delete an item
 
-=item * C<< yancy->create( $collection, $data ) >> - Create an item
+=item * C<< yancy->create( $schema, $data ) >> - Create an item
 
 =back
 
diff --git a/lib/Yancy/Plugin/Auth.pm b/lib/Yancy/Plugin/Auth.pm
index 11bdce94..b70f6c49 100644
--- a/lib/Yancy/Plugin/Auth.pm
+++ b/lib/Yancy/Plugin/Auth.pm
@@ -7,7 +7,7 @@ our $VERSION = '1.026';
     use Mojolicious::Lite;
     plugin Yancy => {
         backend => 'sqlite://myapp.db',
-        collections => {
+        schema => {
             users => {
                 properties => {
                     id => { type => 'integer', readOnly => 1 },
@@ -23,7 +23,7 @@ our $VERSION = '1.026';
         },
     };
     app->yancy->plugin( 'Auth' => {
-        collection => 'users',
+        schema => 'users',
         username_field => 'username',
         password_field => 'password',
         plugin_field => 'plugin',
@@ -54,13 +54,13 @@ directly if you want.
 
 This plugin has the following configuration options.
 
-=head2 collection
+=head2 schema
 
-The name of the Yancy collection that holds users. Required.
+The name of the Yancy schema that holds users. Required.
 
 =head2 username_field
 
-The name of the field in the collection which is the user's identifier.
+The name of the field in the schema which is the user's identifier.
 This can be a user name, ID, or e-mail address, and is provided by the
 user during login.
 
@@ -83,14 +83,14 @@ hash reference of configuration.
 Each of this module's configuration keys will be used as the default for
 all the other auth plugins. Other plugins can override this
 configuration individually. For example, users and tokens can be stored
-in different collections:
+in different schemas:
 
     app->yancy->plugin( 'Auth' => {
         plugins => [
             [
                 'Password',
                 {
-                    collection => 'users',
+                    schema => 'users',
                     username_field => 'username',
                     password_field => 'password',
                     password_digest => { type => 'SHA-1' },
@@ -99,7 +99,7 @@ in different collections:
             [
                 'Token',
                 {
-                    collection => 'tokens',
+                    schema => 'tokens',
                     token_field => 'token',
                 },
             ],
diff --git a/lib/Yancy/Plugin/Auth/Basic.pm b/lib/Yancy/Plugin/Auth/Basic.pm
index 808f9afa..69fa92bf 100644
--- a/lib/Yancy/Plugin/Auth/Basic.pm
+++ b/lib/Yancy/Plugin/Auth/Basic.pm
@@ -9,7 +9,7 @@ our $VERSION = '1.026';
     use Mojolicious::Lite;
     plugin Yancy => {
         backend => 'pg://localhost/mysite',
-        collections => {
+        schema => {
             users => {
                 required => [ 'username', 'password' ],
                 properties => {
@@ -21,7 +21,7 @@ our $VERSION = '1.026';
         },
     };
     app->yancy->plugin( 'Auth::Basic' => {
-        collection => 'users',
+        schema => 'users',
         username_field => 'username',
         password_field => 'password',
         password_digest => {
@@ -45,22 +45,22 @@ This plugin has the following configuration options.
 
 =over
 
-=item collection
+=item schema
 
-The name of the Yancy collection that holds users. Required.
+The name of the Yancy schema that holds users. Required.
 
 =item username_field
 
-The name of the field in the collection which is the user's identifier.
+The name of the field in the schema which is the user's identifier.
 This can be a user name, ID, or e-mail address, and is provided by the
 user during login.
 
-This field is optional. If not specified, the collection's ID field will
-be used. For example, if the collection uses the C<username> field as
+This field is optional. If not specified, the schema's ID field will
+be used. For example, if the schema uses the C<username> field as
 a unique identifier, we don't need to provide a C<username_field>.
 
     plugin Yancy => {
-        collections => {
+        schema => {
             users => {
                 'x-id-field' => 'username',
                 properties => {
@@ -71,7 +71,7 @@ a unique identifier, we don't need to provide a C<username_field>.
         },
     };
     app->yancy->plugin( 'Auth::Basic' => {
-        collection => 'users',
+        schema => 'users',
         password_digest => { type => 'SHA-1' },
     } );
 
@@ -242,12 +242,12 @@ sub register {
     die "Error configuring Auth::Basic plugin: No password digest type defined\n"
         unless $config->{password_digest} && $config->{password_digest}{type};
 
-    my $coll = $config->{collection}
+    my $coll = $config->{schema} || $config->{collection}
         || die "Error configuring Auth::Basic plugin: No collection defined\n";
     die sprintf(
         q{Error configuring Auth::Basic plugin: Collection "%s" not found}."\n",
         $coll,
-    ) unless $app->yancy->config->{collections}{$coll};
+    ) unless $app->yancy->schema( $coll );
 
     warn "The Auth::Basic plugin is deprecated and will be removed in Yancy v2.000. Please migrate to the Auth::Password module.\n";
 
@@ -272,7 +272,11 @@ sub register {
         my ( $name, $value, $field ) = @_;
         return $digest->add( $value )->b64digest;
     } );
-    push @{ $app->yancy->config->{collections}{$coll}{properties}{$password_field}{'x-filter'} }, 'auth.digest';
+
+    # Add the password filter so editing passwords in the editor works
+    my $schema = $app->yancy->schema( $coll );
+    push @{ $schema->{properties}{$password_field}{'x-filter'} }, 'auth.digest';
+    $app->yancy->schema( $coll, $schema );
 
     # Add login pages
     my $route = $config->{route} || $app->yancy->route;
diff --git a/lib/Yancy/Plugin/Auth/Github.pm b/lib/Yancy/Plugin/Auth/Github.pm
index 7ba721d7..629e50b8 100644
--- a/lib/Yancy/Plugin/Auth/Github.pm
+++ b/lib/Yancy/Plugin/Auth/Github.pm
@@ -11,7 +11,7 @@ our $VERSION = '1.026';
     app->yancy->plugin( 'Auth::Github' => {
         client_id => 'CLIENT_ID',
         client_secret => $ENV{ OAUTH_GITHUB_SECRET },
-        collection => 'users',
+        schema => 'users',
         username_field => 'username',
         # TODO: Get other user information from Github, requesting
         # scopes if necessary
@@ -69,14 +69,18 @@ has moniker => 'github';
 has authorize_url => 'https://github.com/login/oauth/authorize';
 has token_url => 'https://github.com/login/oauth/access_token';
 has api_url => 'https://api.github.com/';
-has collection =>;
+has schema =>;
 has username_field =>;
 has plugin_field => 'plugin';
 has allow_register => 0;
 
 sub init {
     my ( $self, $app, $config ) = @_;
-    for my $attr ( qw( collection username_field plugin_field allow_register ) ) {
+    if ( $config->{collection} ) {
+        $self->schema( $config->{collection} );
+        warn "'collection' configuration in Auth::Github is now 'schema'. Please fix your configuration.\n";
+    }
+    for my $attr ( qw( schema username_field plugin_field allow_register ) ) {
         next if !$config->{ $attr };
         $self->$attr( $config->{ $attr } );
     }
@@ -101,8 +105,8 @@ sub current_user {
 
 sub _get_user {
     my ( $self, $c, $username ) = @_;
-    my $coll = $self->collection;
-    my $schema = $c->yancy->schema( $coll );
+    my $schema_name = $self->schema;
+    my $schema = $c->yancy->schema( $schema_name );
     my $username_field = $self->username_field;
     my %search;
     if ( my $field = $self->plugin_field ) {
@@ -110,10 +114,10 @@ sub _get_user {
     }
     if ( $username_field && $username_field ne $schema->{'x-id-field'} ) {
         $search{ $username_field } = $username;
-        my ( $user ) = @{ $c->yancy->backend->list( $coll, \%search, { limit => 1 } )->{items} };
+        my ( $user ) = @{ $c->yancy->backend->list( $schema_name, \%search, { limit => 1 } )->{items} };
         return $user;
     }
-    return $c->yancy->backend->get( $coll, $username );
+    return $c->yancy->backend->get( $schema_name, $username );
 }
 
 =method require_user
@@ -204,9 +208,9 @@ sub handle_token_p {
                 );
                 die 'Registration of new users is not allowed',
             }
-            my $schema = $c->yancy->schema( $self->collection );
+            my $schema = $c->yancy->schema( $self->schema );
             $c->yancy->create(
-                $self->collection,
+                $self->schema,
                 { $self->username_field || $schema->{'x-id-field'} || 'id' => $login },
             );
         }
diff --git a/lib/Yancy/Plugin/Auth/Password.pm b/lib/Yancy/Plugin/Auth/Password.pm
index afb9b16f..e6928955 100644
--- a/lib/Yancy/Plugin/Auth/Password.pm
+++ b/lib/Yancy/Plugin/Auth/Password.pm
@@ -9,7 +9,7 @@ our $VERSION = '1.026';
     use Mojolicious::Lite;
     plugin Yancy => {
         backend => 'sqlite://myapp.db',
-        collections => {
+        schema => {
             users => {
                 properties => {
                     id => { type => 'integer', readOnly => 1 },
@@ -20,7 +20,7 @@ our $VERSION = '1.026';
         },
     };
     app->yancy->plugin( 'Auth::Password' => {
-        collection => 'users',
+        schema => 'users',
         username_field => 'username',
         password_field => 'password',
         password_digest => {
@@ -46,7 +46,7 @@ current password digest settings, you don't need to do anything at all.
     # Migrate from Auth::Basic, which had SHA-1 passwords, to
     # Auth::Password using SHA-256 passwords
     app->yancy->plugin( 'Auth::Password' => {
-        collection => 'users',
+        schema => 'users',
         username_field => 'username',
         password_field => 'password',
         migrate_digest => {
@@ -60,7 +60,7 @@ current password digest settings, you don't need to do anything at all.
     # Migrate from Auth::Basic, which had SHA-1 passwords, to
     # Auth::Password using SHA-1 passwords
     app->yancy->plugin( 'Auth::Password' => {
-        collection => 'users',
+        schema => 'users',
         username_field => 'username',
         password_field => 'password',
         password_digest => {
@@ -72,22 +72,22 @@ current password digest settings, you don't need to do anything at all.
 
 This plugin has the following configuration options.
 
-=head2 collection
+=head2 schema
 
-The name of the Yancy collection that holds users. Required.
+The name of the Yancy schema that holds users. Required.
 
 =head2 username_field
 
-The name of the field in the collection which is the user's identifier.
+The name of the field in the schema which is the user's identifier.
 This can be a user name, ID, or e-mail address, and is provided by the
 user during login.
 
-This field is optional. If not specified, the collection's ID field will
-be used. For example, if the collection uses the C<username> field as
+This field is optional. If not specified, the schema's ID field will
+be used. For example, if the schema uses the C<username> field as
 a unique identifier, we don't need to provide a C<username_field>.
 
     plugin Yancy => {
-        collections => {
+        schema => {
             users => {
                 'x-id-field' => 'username',
                 properties => {
@@ -98,7 +98,7 @@ a unique identifier, we don't need to provide a C<username_field>.
         },
     };
     app->yancy->plugin( 'Auth::Password' => {
-        collection => 'users',
+        schema => 'users',
         password_digest => { type => 'SHA-1' },
     } );
 
@@ -244,7 +244,7 @@ use Yancy::Util qw( currym );
 use Digest;
 
 has log =>;
-has collection =>;
+has schema =>;
 has username_field =>;
 has password_field => 'password';
 has allow_register => 0;
@@ -272,23 +272,25 @@ sub register {
 
 sub init {
     my ( $self, $app, $config ) = @_;
-    my $coll = $config->{collection}
-        || die "Error configuring Auth::Password plugin: No collection defined\n";
-    my $schema = $app->yancy->schema( $coll );
+    my $schema_name = $config->{schema} || $config->{collection}
+        || die "Error configuring Auth::Password plugin: No schema defined\n";
+    warn "'collection' configuration in Auth::Token is now 'schema'. Please fix your configuration.\n"
+        if $config->{collection};
+    my $schema = $app->yancy->schema( $schema_name );
     die sprintf(
         q{Error configuring Auth::Password plugin: Collection "%s" not found}."\n",
-        $coll,
+        $schema_name,
     ) unless $schema;
 
     $self->log( $app->log );
-    $self->collection( $coll );
+    $self->schema( $schema_name );
     $self->username_field( $config->{username_field} );
     $self->password_field( $config->{password_field} || 'password' );
     $self->default_digest( $config->{password_digest} );
     $self->migrate_digest( $config->{migrate_digest} );
     $self->allow_register( $config->{allow_register} );
     $self->register_fields(
-        $config->{register_fields} || $app->yancy->schema( $coll )->{required}
+        $config->{register_fields} || $app->yancy->schema( $schema_name )->{required}
     );
     $app->yancy->filter->add( 'yancy.plugin.auth.password' => sub {
         my ( $key, $value, $schema, @params ) = @_;
@@ -300,7 +302,7 @@ sub init {
     push @{ $field->{ 'x-filter' } ||= [] },
         'yancy.plugin.auth.password';
     $field->{ format } = 'password';
-    $app->yancy->schema( $coll, $schema );
+    $app->yancy->schema( $schema_name, $schema );
 
     # Add fields that may not technically be required by the schema, but
     # are required for registration
@@ -325,7 +327,7 @@ sub init {
 
 sub _get_user {
     my ( $self, $c, $username ) = @_;
-    my $coll = $self->collection;
+    my $schema_name = $self->schema;
     my $username_field = $self->username_field;
     my %search;
     if ( my $field = $self->plugin_field ) {
@@ -333,10 +335,10 @@ sub _get_user {
     }
     if ( $username_field ) {
         $search{ $username_field } = $username;
-        my ( $user ) = @{ $c->yancy->backend->list( $coll, \%search, { limit => 1 } )->{items} };
+        my ( $user ) = @{ $c->yancy->backend->list( $schema_name, \%search, { limit => 1 } )->{items} };
         return $user;
     }
-    return $c->yancy->backend->get( $coll, $username );
+    return $c->yancy->backend->get( $schema_name, $username );
 }
 
 sub _digest_password {
@@ -358,13 +360,13 @@ sub _set_password {
     }
 
     my $id = $self->_get_id_for_username( $c, $username );
-    $c->yancy->backend->set( $self->collection, $id, { $self->password_field => $password_string } );
+    $c->yancy->backend->set( $self->schema, $id, { $self->password_field => $password_string } );
 }
 
 sub _get_id_for_username {
     my ( $self, $c, $username ) = @_;
-    my $collection = $self->collection;
-    my $schema = $c->yancy->schema( $collection );
+    my $schema_name = $self->schema;
+    my $schema = $c->yancy->schema( $schema_name );
     my $id = $username;
     my $id_field = $schema->{'x-id-field'} || 'id';
     my $username_field = $self->username_field;
@@ -436,8 +438,8 @@ sub _post_register {
         return;
     }
 
-    my $collection = $self->collection;
-    my $schema = $c->yancy->schema( $collection );
+    my $schema_name = $self->schema;
+    my $schema = $c->yancy->schema( $schema_name );
     my $username_field = $self->username_field || $schema->{'x-id-field'} || 'id';
     my $password_field = $self->password_field;
 
@@ -470,7 +472,7 @@ sub _post_register {
             @{ $self->register_fields }
         ),
     };
-    my $id = eval { $c->yancy->create( $collection, $item ) };
+    my $id = eval { $c->yancy->create( $schema_name, $item ) };
     if ( my $exception = $@ ) {
         my $error = ref $exception eq 'ARRAY' ? 'validation' : 'create';
         $c->app->log->error( 'Error creating user: ' . $exception );
diff --git a/lib/Yancy/Plugin/Auth/Token.pm b/lib/Yancy/Plugin/Auth/Token.pm
index 66126c82..30d58700 100644
--- a/lib/Yancy/Plugin/Auth/Token.pm
+++ b/lib/Yancy/Plugin/Auth/Token.pm
@@ -7,7 +7,7 @@ our $VERSION = '1.026';
     use Mojolicious::Lite;
     plugin Yancy => {
         backend => 'sqlite://myapp.db',
-        collections => {
+        schema => {
             tokens => {
                 properties => {
                     id => { type => 'integer', readOnly => 1 },
@@ -18,7 +18,7 @@ our $VERSION = '1.026';
         },
     };
     app->yancy->plugin( 'Auth::Token' => {
-        collection => 'tokens',
+        schema => 'tokens',
         username_field => 'username',
         token_field => 'token',
         token_digest => {
@@ -40,9 +40,9 @@ a site. Tokens are provided in the HTTP C<Authorization> header:
 
 This plugin has the following configuration options.
 
-=head2 collection
+=head2 schema
 
-The name of the Yancy collection that holds tokens. Required.
+The name of the Yancy schema that holds tokens. Required.
 
 =head2 token_field
 
@@ -75,7 +75,7 @@ Not all Digest types require additional configuration.
 
 =head2 username_field
 
-The name of the field in the collection which is the user's identifier.
+The name of the field in the schema which is the user's identifier.
 This can be a user name, ID, or e-mail address, and is used to keep track
 of who owns the token.
 
@@ -123,7 +123,7 @@ use Mojo::Base 'Mojolicious::Plugin';
 use Yancy::Util qw( currym );
 use Digest;
 
-has collection =>;
+has schema =>;
 has username_field =>;
 has token_field =>;
 has token_digest =>;
@@ -146,14 +146,16 @@ sub register {
 
 sub init {
     my ( $self, $app, $config ) = @_;
-    my $coll = $config->{collection}
-        || die "Error configuring Auth::Token plugin: No collection defined\n";
+    my $schema = $config->{schema} || $config->{collection}
+        || die "Error configuring Auth::Token plugin: No schema defined\n";
+    warn "'collection' configuration in Auth::Token is now 'schema'. Please fix your configuration.\n"
+        if $config->{collection};
     die sprintf(
-        q{Error configuring Auth::Token plugin: Collection "%s" not found}."\n",
-        $coll,
-    ) unless $app->yancy->config->{collections}{$coll};
+        q{Error configuring Auth::Token plugin: Schema "%s" not found}."\n",
+        $schema,
+    ) unless $app->yancy->schema( $schema );
 
-    $self->collection( $coll );
+    $self->schema( $schema );
     $self->username_field( $config->{username_field} );
     $self->token_field(
         $config->{token_field} || $config->{password_field} || 'token'
@@ -184,13 +186,13 @@ sub current_user {
     my ( $self, $c ) = @_;
     return undef unless my $auth = $c->req->headers->authorization;
     return undef unless my ( $token ) = $auth =~ /^Token\ (\S+)$/;
-    my $collection = $self->collection;
+    my $schema = $self->schema;
     my %search;
     $search{ $self->token_field } = $token;
     if ( my $field = $self->plugin_field ) {
         $search{ $field } = $self->moniker;
     }
-    my @users = $c->yancy->list( $collection, \%search );
+    my @users = $c->yancy->list( $schema, \%search );
     if ( @users > 1 ) {
         die "Refusing to auth: Multiple users with the same token found";
         return undef;
@@ -222,7 +224,7 @@ sub add_token {
     my @parts = ( $username, $c->app->secrets->[0], $$, scalar time, int rand 1_000_000 );
     my $token = $self->token_digest->clone->add( join "", @parts )->b64digest;
     my $username_field = $self->username_field;
-    $c->yancy->create( $self->collection, {
+    $c->yancy->create( $self->schema, {
         ( $username_field ? ( $username_field => $username ) : () ),
         $self->token_field => $token,
         ( $self->plugin_field ? ( $self->plugin_field => $self->moniker ) : () ),
diff --git a/lib/Yancy/Plugin/Form.pm b/lib/Yancy/Plugin/Form.pm
index d6969f46..f8dd00c6 100644
--- a/lib/Yancy/Plugin/Form.pm
+++ b/lib/Yancy/Plugin/Form.pm
@@ -12,7 +12,7 @@ our $VERSION = '1.026';
     app->yancy->plugin( 'Form::Bootstrap4' );
     app->routes->get( '/people/:id/edit' )->to(
         'yancy#set',
-        collection => 'people',
+        schema => 'people',
         template => 'edit_people',
     );
     app->start;
@@ -126,19 +126,19 @@ how Yancy translates JSON schema into forms.
 
 =head2 yancy->form->field_for
 
-    my $html = $c->yancy->form->field_for( $collection, $name );
-    %= $c->yancy->form->field_for( $collection, $name );
+    my $html = $c->yancy->form->field_for( $schema, $name );
+    %= $c->yancy->form->field_for( $schema, $name );
 
-Generate a field for the given C<$collection> and property C<$name>. The
+Generate a field for the given C<$schema> and property C<$name>. The
 field will include a C<< <label> >>, the appropriate input (C<< <input>
 >>, C<< <select> >>, or otherwise ), and any descriptive text.
 
 =head2 yancy->form->form_for
 
-    my $html = $c->yancy->form->form_for( $collection, %opt );
-    %= $c->yancy->form->plugin( $collection, %opt );
+    my $html = $c->yancy->form->form_for( $schema, %opt );
+    %= $c->yancy->form->plugin( $schema, %opt );
 
-Generate a form to edit an item from the given C<$collection>. The form
+Generate a form to edit an item from the given C<$schema>. The form
 will include all the fields, a CSRF token, and a single button to submit
 the form.
 
diff --git a/lib/Yancy/Plugin/Form/Bootstrap4.pm b/lib/Yancy/Plugin/Form/Bootstrap4.pm
index 5053ea04..d30abc59 100644
--- a/lib/Yancy/Plugin/Form/Bootstrap4.pm
+++ b/lib/Yancy/Plugin/Form/Bootstrap4.pm
@@ -13,7 +13,7 @@ our $VERSION = '1.026';
     # See Yancy::Controller::Yancy for routing
     app->routes->get( '/people/:id/edit' )->to(
         'yancy#set',
-        collection => 'people',
+        schema => 'people',
         template => 'edit_people',
     );
     app->start;
diff --git a/lib/Yancy/Util.pm b/lib/Yancy/Util.pm
index 5837e2ec..e77acd9a 100644
--- a/lib/Yancy/Util.pm
+++ b/lib/Yancy/Util.pm
@@ -5,7 +5,7 @@ our $VERSION = '1.026';
 =head1 SYNOPSIS
 
     use Yancy::Util qw( load_backend );
-    my $be = load_backend( 'test://localhost', $collections );
+    my $be = load_backend( 'test://localhost', $schema );
 
     use Yancy::Util qw( curry );
     my $helper = curry( \&_helper_sub, @args );
@@ -40,12 +40,12 @@ our @EXPORT_OK = qw( load_backend curry currym copy_inline_refs match );
 
 =sub load_backend
 
-    my $backend = load_backend( $backend_url, $collections );
-    my $backend = load_backend( { $backend_name => $arg }, $collections );
+    my $backend = load_backend( $backend_url, $schema );
+    my $backend = load_backend( { $backend_name => $arg }, $schema );
 
 Get a Yancy backend from the given backend URL, or from a hash reference
-with a backend name and optional argument. The C<$collections> hash is
-the configured collections for this backend.
+with a backend name and optional argument. The C<$schema> hash is
+the configured JSON schema for this backend.
 
 A backend URL should begin with a name followed by a colon. The first
 letter of the name will be capitalized, and used to build a class name
@@ -62,11 +62,11 @@ objects.
 =cut
 
 sub load_backend {
-    my ( $config, $collections ) = @_;
+    my ( $config, $schema ) = @_;
     my ( $type, $arg );
     if ( !ref $config ) {
         ( $type ) = $config =~ m{^([^:]+)};
-        $arg = $config
+        $arg = $config;
     }
     else {
         ( $type, $arg ) = %{ $config };
@@ -75,7 +75,7 @@ sub load_backend {
     if ( my $e = load_class( $class ) ) {
         die ref $e ? "Could not load class $class: $e" : "Could not find class $class";
     }
-    return $class->new( $arg, $collections );
+    return $class->new( $arg, $schema );
 }
 
 =sub curry
diff --git a/t/api.t b/t/api.t
index e5a239c4..126bbffa 100644
--- a/t/api.t
+++ b/t/api.t
@@ -61,7 +61,7 @@ my %data = (
 );
 
 my ( $backend_url, $backend, %items ) = init_backend( $collections, %data );
-subtest 'declared collections' => \&test_api,
+subtest 'declared schema' => \&test_api,
     Test::Mojo->new( 'Yancy', {
         backend => $backend_url,
         collections => $collections,
@@ -98,7 +98,7 @@ subtest 'exception on unknown HTTP method' => sub {
 
 $openapi = decode_json path ( $Bin, 'share', 'openapi-spec.json' )->slurp;
 $openapi->{paths}{"/nonexistent"} = {};
-subtest 'exception on non-inferrable collection' => sub {
+subtest 'exception on non-inferrable schema' => sub {
     eval {Test::Mojo->new( 'Yancy', {
         backend => $backend_url,
         openapi => $openapi,
@@ -108,7 +108,7 @@ subtest 'exception on non-inferrable collection' => sub {
 
 $openapi = decode_json path ( $Bin, 'share', 'openapi-spec.json' )->slurp;
 $openapi->{paths}{"/people"} = {};
-subtest 'inferrable collection' => sub {
+subtest 'inferrable schema' => sub {
     eval {Test::Mojo->new( 'Yancy', {
         backend => $backend_url,
         openapi => $openapi,
@@ -124,6 +124,7 @@ sub test_api {
     subtest 'fetch generated OpenAPI spec '.$api_path => sub {
         $t->get_ok( $api_path )
           ->status_is( 200 )
+          ->or( sub { diag shift->tx->res->body } )
           ->content_type_like( qr{^application/json} )
           ->json_is( '/definitions/people' => {
             type => 'object',
@@ -208,7 +209,7 @@ sub test_api {
             type => 'object',
             'x-id-field' => 'username',
             'x-list-columns' => [qw( username email )],
-            'x-view' => { collection => 'user' },
+            'x-view' => { schema => 'user' },
             properties => {
                 id => {
                     'x-order' => 1,
diff --git a/t/backend/mock.t b/t/backend/mock.t
index 1ad70de7..82bce856 100644
--- a/t/backend/mock.t
+++ b/t/backend/mock.t
@@ -30,7 +30,7 @@ my $be;
 subtest 'new' => sub {
     ( my $backend_url, $be ) = init_backend( $collections );
     isa_ok $be, 'Yancy::Backend::Test';
-    is_deeply $be->collections, $collections;
+    is_deeply $be->schema, $collections;
 };
 
 sub insert_item {
diff --git a/t/config.t b/t/config.t
index db24971b..516ad75b 100644
--- a/t/config.t
+++ b/t/config.t
@@ -199,7 +199,7 @@ subtest 'errors' => sub {
         );
         eval { Yancy->new( config => \%missing_id ) };
         ok $@, 'configuration dies';
-        like $@, qr{ID field missing in properties for collection 'foo', field 'id'},
+        like $@, qr{ID field missing in properties for schema 'foo', field 'id'},
             'error is correct';
 
         my %missing_x_id = (
@@ -215,7 +215,7 @@ subtest 'errors' => sub {
         );
         eval { Yancy->new( config => \%missing_x_id ) };
         ok $@, 'configuration dies';
-        like $@, qr{ID field missing in properties for collection 'foo', field 'bar'},
+        like $@, qr{ID field missing in properties for schema 'foo', field 'bar'},
             'error is correct';
 
         my %ignored_missing_id = (
@@ -232,14 +232,14 @@ subtest 'errors' => sub {
         ok !$@, 'configuration succeeds' or diag $@;
     };
 
-    subtest 'no collections AND openapi' => sub {
+    subtest 'no schema AND openapi' => sub {
         eval { Yancy->new( config => {
             openapi => {},
             backend => $backend_url,
             collections => {},
         } ) };
-        ok $@, 'openapi AND collections should be fatal';
-        like $@, qr{Cannot pass both openapi AND \(collections or read_schema\)};
+        ok $@, 'openapi AND schema should be fatal';
+        like $@, qr{Cannot pass both openapi AND \(schema or read_schema\)};
     };
 
 };
diff --git a/t/controller/multi_tenant.t b/t/controller/multi_tenant.t
index 029b2a09..68718356 100644
--- a/t/controller/multi_tenant.t
+++ b/t/controller/multi_tenant.t
@@ -202,7 +202,7 @@ subtest 'list' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/list/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
         $t->get_ok( '/error/list/nouserid' )
           ->status_is( 500 )
           ->content_like( qr{User ID not defined in stash} );
@@ -222,7 +222,7 @@ subtest 'get' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/get/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
         $t->get_ok( '/error/get/noid' )
           ->status_is( 500 )
           ->content_like( qr{ID not defined in stash} );
@@ -370,7 +370,7 @@ subtest 'set' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/set/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
         $t->get_ok( '/error/set/nouserid' )
           ->status_is( 500 )
           ->content_like( qr{User ID not defined in stash} );
@@ -488,7 +488,7 @@ subtest 'delete' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/delete/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
         $t->get_ok( '/error/delete/noid' )
           ->status_is( 500 )
           ->content_like( qr{ID not defined in stash} );
diff --git a/t/controller/yancy.t b/t/controller/yancy.t
index b36b0747..89dc12e1 100644
--- a/t/controller/yancy.t
+++ b/t/controller/yancy.t
@@ -171,7 +171,7 @@ subtest 'list' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/list/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
     };
 
     subtest 'subclassing/extending' => sub {
@@ -196,7 +196,7 @@ subtest 'get' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/get/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
         $t->get_ok( '/error/get/noid' )
           ->status_is( 500 )
           ->content_like( qr{ID not defined in stash} );
@@ -251,7 +251,8 @@ subtest 'set' => sub {
             my @warnings;
             local $SIG{__WARN__} = sub { push @warnings, @_ };
             $t->post_ok( "/edit/$items{blog}[0]{id}" => form => \%form_data );
-            ok !@warnings, 'no warnings generated by post' or diag explain \@warnings;
+            ok !(grep !/"collection" stash key is now "schema"/, @warnings),
+                'no warnings generated by post' or diag explain \@warnings;
         }
 
         $t->status_is( 200 )
@@ -303,7 +304,8 @@ subtest 'set' => sub {
             my @warnings;
             local $SIG{__WARN__} = sub { push @warnings, @_ };
             $t->post_ok( '/edit' => form => \%form_data );
-            ok !@warnings, 'no warnings generated by post' or diag explain \@warnings;
+            ok !(grep !/"collection" stash key is now "schema"/, @warnings),
+                'no warnings generated by post' or diag explain \@warnings;
         }
 
         $t->status_is( 302 )
@@ -331,7 +333,8 @@ subtest 'set' => sub {
             my @warnings;
             local $SIG{__WARN__} = sub { push @warnings, @_ };
             $t->post_ok( "/edit/$items{blog}[0]{id}" => { Accept => 'application/json' }, form => \%json_data );
-            ok !@warnings, 'no warnings generated by post' or diag explain \@warnings;
+            ok !(grep !/"collection" stash key is now "schema"/, @warnings),
+                'no warnings generated by post' or diag explain \@warnings;
         }
 
         $t->status_is( 200 )
@@ -362,7 +365,8 @@ subtest 'set' => sub {
             my @warnings;
             local $SIG{__WARN__} = sub { push @warnings, @_ };
             $t->post_ok( '/edit' => { Accept => 'application/json' }, form => \%json_data );
-            ok !@warnings, 'no warnings generated by post' or diag explain \@warnings;
+            ok !(grep !/"collection" stash key is now "schema"/, @warnings),
+                'no warnings generated by post' or diag explain \@warnings;
         }
 
         $t->status_is( 201 )
@@ -402,7 +406,8 @@ subtest 'set' => sub {
             local $SIG{__WARN__} = sub { push @warnings, @_ };
             $t->post_ok( "/user/$items{user}[0]{username}/edit" => form => \%form_data );
             $items{user}[0]{username} = $form_data{username}; # x-id-field
-            ok !@warnings, 'no warnings generated by post' or diag explain \@warnings;
+            ok !(grep !/"collection" stash key is now "schema"/, @warnings),
+                'no warnings generated by post' or diag explain \@warnings;
         }
 
         $t->status_is( 200 )
@@ -436,7 +441,8 @@ subtest 'set' => sub {
             my @warnings;
             local $SIG{__WARN__} = sub { push @warnings, @_ };
             $t->post_ok( "/user/$items{user}[0]{username}/profile" => form => \%form_data );
-            ok !@warnings, 'no warnings generated by post' or diag explain \@warnings;
+            ok !(grep !/"collection" stash key is now "schema"/, @warnings),
+                'no warnings generated by post' or diag explain \@warnings;
         }
 
         $t->status_is( 200 )
@@ -468,7 +474,8 @@ subtest 'set' => sub {
             {
                 my @warnings;
                 local $SIG{__WARN__} = sub { push @warnings, @_ };
-                ok !@warnings, 'no warnings generated by post' or diag explain \@warnings;
+                ok !(grep !/"collection" stash key is now "schema"/, @warnings),
+                    'no warnings generated by post' or diag explain \@warnings;
             }
 
             $t->post_ok( "/user/$items{user}[0]{username}/profile" => form => \%form_data )
@@ -488,7 +495,7 @@ subtest 'set' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/set/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
         $t->get_ok( "/edit/$items{blog}[0]{id}" => { Accept => 'application/json' } )
           ->status_is( 400 )
           ->json_is( {
@@ -670,7 +677,7 @@ subtest 'delete' => sub {
     subtest 'errors' => sub {
         $t->get_ok( '/error/delete/nocollection' )
           ->status_is( 500 )
-          ->content_like( qr{Collection name not defined in stash} );
+          ->content_like( qr{Schema name not defined in stash} );
         $t->get_ok( '/error/delete/noid' )
           ->status_is( 500 )
           ->content_like( qr{ID not defined in stash} );
diff --git a/t/filter.t b/t/filter.t
index 6b8f1c6e..dfd75ff1 100644
--- a/t/filter.t
+++ b/t/filter.t
@@ -56,8 +56,8 @@ my $t = Test::Mojo->new( 'Yancy', {
 } );
 
 subtest 'register and run a filter' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
     $t->app->yancy->filter->add(
         'test.digest' => sub {
             my ( $name, $value, $conf ) = @_;
@@ -80,7 +80,7 @@ subtest 'register and run a filter' => sub {
 };
 
 subtest 'register and run parameterised filter' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-filter'} = [ [ 'test.with_params', 'hi' ] ];
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-filter'} = [ [ 'test.with_params', 'hi' ] ];
     $t->app->yancy->filter->add(
         'test.with_params' => sub {
             my ( $name, $value, $conf, @params ) = @_;
@@ -99,7 +99,7 @@ subtest 'register and run parameterised filter' => sub {
 };
 
 subtest 'run wrap filter' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{email}{'x-filter'} = [ [ 'yancy.wrap', 'hi' ] ];
+    local $t->app->yancy->config->{schema}{user}{properties}{email}{'x-filter'} = [ [ 'yancy.wrap', 'hi' ] ];
     my $email = 'filter@example.com';
     my $user = {
         username => 'unfiltered',
@@ -113,7 +113,7 @@ subtest 'run wrap filter' => sub {
 };
 
 subtest 'run unwrap filter' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{email}{'x-filter'} = [
+    local $t->app->yancy->config->{schema}{user}{properties}{email}{'x-filter'} = [
         [ 'yancy.wrap', qw(hi there) ],
         [ 'yancy.unwrap', qw(there hi) ],
     ];
@@ -128,7 +128,7 @@ subtest 'run unwrap filter' => sub {
 };
 
 subtest 'filter no mutate input' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{email}{'x-filter'} = [ [ 'yancy.wrap', 'hi' ] ];
+    local $t->app->yancy->config->{schema}{user}{properties}{email}{'x-filter'} = [ [ 'yancy.wrap', 'hi' ] ];
     my $user = {
         username => 'unfiltered',
         email => 'filter@example.com',
@@ -139,7 +139,7 @@ subtest 'filter no mutate input' => sub {
 };
 
 subtest 'run from_helper filter' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-filter'} = [ [ 'yancy.from_helper', 'yancy.hello' ] ];
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-filter'} = [ [ 'yancy.from_helper', 'yancy.hello' ] ];
     $t->app->helper( 'yancy.hello' => sub { 'Hi there!' } );
     my $user = {
         username => 'filter',
@@ -160,7 +160,7 @@ subtest 'filter works recursively' => sub {
             return $value;
         },
     );
-    local $t->app->yancy->config->{collections}{people}{'x-filter'} = [ 'test.lc_email' ];
+    local $t->app->yancy->config->{schema}{people}{'x-filter'} = [ 'test.lc_email' ];
 
     my $person = {
         name => 'Doug',
@@ -172,7 +172,7 @@ subtest 'filter works recursively' => sub {
 };
 
 subtest 'run overlay_from_helper filter' => sub {
-    local $t->app->yancy->config->{collections}{people}{'x-filter'}[0] = [ 'yancy.overlay_from_helper' => 'email', 'yancy.hello' ];
+    local $t->app->yancy->config->{schema}{people}{'x-filter'}[0] = [ 'yancy.overlay_from_helper' => 'email', 'yancy.hello' ];
     my $person = {
         name => 'Doug',
         email => 'dOuG@pReAcTiOn.me',
@@ -183,8 +183,8 @@ subtest 'run overlay_from_helper filter' => sub {
 };
 
 subtest 'api runs filters during set' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
     my $doug = {
         %{ $backend->get( user => 'doug' ) },
         password => 'qwe123',
@@ -198,8 +198,8 @@ subtest 'api runs filters during set' => sub {
 };
 
 subtest 'api runs filters during create' => sub {
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
     my $new_user = {
         username => 'qubert',
         email => 'qubert@example.com',
@@ -226,8 +226,8 @@ subtest 'register filters from config' => sub {
         },
     } );
 
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
-    local $t->app->yancy->config->{collections}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-filter'} = [ 'test.digest' ];
+    local $t->app->yancy->config->{schema}{user}{properties}{password}{'x-digest'} = { type => 'SHA-1' };
 
     my $user = {
         username => 'filter',
diff --git a/t/helpers.t b/t/helpers.t
index dec34b4d..e27c9742 100644
--- a/t/helpers.t
+++ b/t/helpers.t
@@ -117,7 +117,7 @@ subtest 'set' => sub {
         #; print explain $t->app->log->history;
         is $t->app->log->history->[-1][1], 'error',
             'error message is logged at error level';
-        like $t->app->log->history->[-1][2], qr{Error validating item with ID "$set_id" in collection "people": $message \($path\)},
+        like $t->app->log->history->[-1][2], qr{Error validating item with ID "$set_id" in schema "people": $message \($path\)},
             'error message is logged with JSON validation error';
 
         is_deeply $backend->get( people => $set_id ), $new_person,
@@ -127,7 +127,7 @@ subtest 'set' => sub {
         $path = $@->[0]{path};
         is $t->app->log->history->[-1][1], 'error',
             'error message is logged at error level';
-        like $t->app->log->history->[-1][2], qr{Error validating item with ID "$set_id" in collection "people": $message \($path\)},
+        like $t->app->log->history->[-1][2], qr{Error validating item with ID "$set_id" in schema "people": $message \($path\)},
             'error message is logged with JSON validation error';
     };
 
@@ -260,7 +260,7 @@ subtest 'set' => sub {
         is $t->app->log->history->[-1][1], 'error',
             'error message is logged at error level';
         like $t->app->log->history->[-1][2],
-            qr{Error setting item with ID "$set_id" in collection "people": Died},
+            qr{Error setting item with ID "$set_id" in schema "people": Died},
             'error message is logged with backend error';
     };
 
@@ -303,7 +303,7 @@ subtest 'create' => sub {
         my $path = $@->[0]{path};
         is $t->app->log->history->[-1][1], 'error',
             'error message is logged at error level';
-        like $t->app->log->history->[-1][2], qr{Error validating new item in collection "people": $message \($path\)},
+        like $t->app->log->history->[-1][2], qr{Error validating new item in schema "people": $message \($path\)},
             'error message is logged with JSON validation error';
 
         is $backend->list( 'people' )->{total},
@@ -324,7 +324,7 @@ subtest 'create' => sub {
         is $t->app->log->history->[-1][1], 'error',
             'error message is logged at error level';
         like $t->app->log->history->[-1][2],
-            qr{Error creating item in collection "people": Died},
+            qr{Error creating item in schema "people": Died},
             'error message is logged with backend error';
     };
 
diff --git a/t/lib/Local/Test.pm b/t/lib/Local/Test.pm
index b009565e..0fd69bd6 100644
--- a/t/lib/Local/Test.pm
+++ b/t/lib/Local/Test.pm
@@ -217,7 +217,7 @@ END {
         type => 'object',
         'x-id-field' => 'username',
         'x-list-columns' => [qw( username email )],
-        'x-view' => { collection => 'user' },
+        'x-view' => { schema => 'user' },
         properties => {
             id => {
                 'x-order' => 1,
@@ -241,7 +241,7 @@ END {
         type => 'object',
         'x-id-field' => 'username',
         'x-list-columns' => [qw( username email )],
-        'x-view' => { collection => 'user' },
+        'x-view' => { schema => 'user' },
     },
 );
 %Yancy::Backend::Test::SCHEMA_MICRO = (
@@ -265,7 +265,7 @@ END {
         type => 'object',
         'x-id-field' => 'username',
         'x-list-columns' => [qw( username email )],
-        'x-view' => { collection => 'user' },
+        'x-view' => { schema => 'user' },
         properties => {
             id => {
                 'x-order' => 1,
@@ -289,7 +289,7 @@ END {
         type => 'object',
         'x-id-field' => 'username',
         'x-list-columns' => [qw( username email )],
-        'x-view' => { collection => 'user' },
+        'x-view' => { schema => 'user' },
     },
 );
 @Yancy::Backend::Test::SCHEMA_ADDED_COLLS = qw(
diff --git a/t/lib/Yancy/Backend/Test.pm b/t/lib/Yancy/Backend/Test.pm
index c7057d82..f865b204 100644
--- a/t/lib/Yancy/Backend/Test.pm
+++ b/t/lib/Yancy/Backend/Test.pm
@@ -28,7 +28,7 @@ sub new {
     return bless { init_arg => $url, collections => $collections }, $class;
 }
 
-sub collections {
+sub schema {
     my ( $self, $collections ) = @_;
     if ( $collections ) {
         $self->{collections} = $collections;
@@ -36,6 +36,8 @@ sub collections {
     }
     $self->{collections};
 }
+sub collections;
+*collections = *schema;
 
 sub create {
     my ( $self, $coll, $params ) = @_;
@@ -65,7 +67,7 @@ sub create {
 sub get {
     my ( $self, $coll, $id ) = @_;
     my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my $real_coll = ( $schema->{'x-view'} || {} )->{schema} // $coll;
     my $item = $COLLECTIONS{ $real_coll }{ $id // '' };
     return undef unless $item;
     $self->_viewise( $coll, $item );
@@ -75,7 +77,7 @@ sub _viewise {
     my ( $self, $coll, $item ) = @_;
     $item = dclone $item;
     my $schema = $self->collections->{ $coll };
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my $real_coll = ( $schema->{'x-view'} || {} )->{schema} // $coll;
     my $props = $schema->{properties}
         || $self->collections->{ $real_coll }{properties};
     delete $item->{$_} for grep !$props->{ $_ }, keys %$item;
@@ -107,7 +109,7 @@ sub list {
     die "list attempted on non-existent collection '$coll'" unless $schema;
     $params ||= {}; $opt ||= {};
     my $id_field = $schema->{ 'x-id-field' } || 'id';
-    my $real_coll = ( $schema->{'x-view'} || {} )->{collection} // $coll;
+    my $real_coll = ( $schema->{'x-view'} || {} )->{schema} // $coll;
     my $props = $schema->{properties}
         || $self->collections->{ $real_coll }{properties};
     my ( $sort_field, $sort_order ) = _order_by( $id_field, $opt->{order_by} );
diff --git a/t/share/openapi-spec.json b/t/share/openapi-spec.json
index fce98c98..8630ffbc 100644
--- a/t/share/openapi-spec.json
+++ b/t/share/openapi-spec.json
@@ -203,7 +203,7 @@
             "email"
          ],
          "x-view" : {
-            "collection" : "user"
+            "schema" : "user"
          }
       },
       "userviewnoprops" : {
@@ -214,7 +214,7 @@
             "email"
          ],
          "x-view" : {
-            "collection" : "user"
+            "schema" : "user"
          }
       }
    },