chore(build): update synth config to generate README.md (#213)

Author: BenWhitehead

.readme-partials.yaml

@@ -0,0 +1,122 @@
+custom_content: |
+  See the [Google Cloud Datastore docs][cloud-datastore-activation] for more details on how to activate
+  Cloud Datastore for your project.
+
+  See the [Datastore client library docs][datastore-client-lib-docs] to learn how to interact
+  with the Cloud Datastore using this Client Library.
+
+  #### Creating an authorized service object
+  To make authenticated requests to Google Cloud Datastore, you must create a service object with credentials. You can then make API calls by calling methods on the Datastore service object. The simplest way to authenticate is to use [Application Default Credentials](https://developers.google.com/identity/protocols/application-default-credentials). These credentials are automatically inferred from your environment, so you only need the following code to create your service object:
+
+  ```java
+  import com.google.cloud.datastore.Datastore;
+  import com.google.cloud.datastore.DatastoreOptions;
+
+  Datastore datastore = DatastoreOptions.getDefaultInstance().getService();
+  ```
+
+  For other authentication options, see the [Authentication](https://github.com/googleapis/google-cloud-java#authentication) page.
+
+  #### Storing data
+  Objects in Datastore are known as entities. Entities are grouped by "kind" and have keys for easy access. In this code snippet, we will create a new entity representing a person and store that data by the person's email.  First, add the following imports at the top of your file:
+
+  ```java
+  import com.google.cloud.datastore.Entity;
+  import com.google.cloud.datastore.Key;
+  import com.google.cloud.datastore.KeyFactory;
+  ```
+
+  Then add the following code to put an entity in Datastore.
+
+  ```java
+  KeyFactory keyFactory = datastore.newKeyFactory().setKind("Person");
+  Key key = keyFactory.newKey("[email protected]");
+  Entity entity = Entity.newBuilder(key)
+      .set("name", "John Doe")
+      .set("age", 51)
+      .set("favorite_food", "pizza")
+      .build();
+  datastore.put(entity);
+  ```
+
+  Later, if you want to get this entity back, add the following to your code:
+
+  ```java
+  Entity johnEntity = datastore.get(key);
+  ```
+
+  #### Running a query
+  In addition to retrieving entities by their keys, you can perform queries to retrieve entities by
+  the values of their properties. A typical query includes an entity kind, filters to select entities
+  with matching values, and sort orders to sequence the results. `google-cloud-datastore` supports two
+  types of queries: `StructuredQuery` (that allows you to construct query elements) and `GqlQuery`
+  (which operates using [GQL syntax](https://cloud.google.com/datastore/docs/apis/gql/gql_reference))
+  in string format. In this tutorial, we will use a simple `StructuredQuery`.
+
+  Suppose that you've added more people to Datastore, and now you want to find all people whose favorite food is pizza. Import the following:
+
+  ```java
+  import com.google.cloud.datastore.Query;
+  import com.google.cloud.datastore.QueryResults;
+  import com.google.cloud.datastore.StructuredQuery;
+  import com.google.cloud.datastore.StructuredQuery.PropertyFilter;
+  ```
+
+  Then add the following code to your program:
+
+  ```java
+  Query<Entity> query = Query.newEntityQueryBuilder()
+      .setKind("Person")
+      .setFilter(PropertyFilter.eq("favorite_food", "pizza"))
+      .build();
+  QueryResults<Entity> results = datastore.run(query);
+  while (results.hasNext()) {
+    Entity currentEntity = results.next();
+    System.out.println(currentEntity.getString("name") + ", you're invited to a pizza party!");
+  }
+  ```
+
+  Cloud Datastore relies on indexing to run queries. Indexing is turned on by default for most types of properties. To read more about indexing, see the [Cloud Datastore Index Configuration documentation](https://cloud.google.com/datastore/docs/tools/indexconfig).
+
+  #### Updating data
+  Another thing you'll probably want to do is update your data. The following snippet shows how to update a Datastore entity if it exists.
+
+  ``` java
+  KeyFactory keyFactory = datastore.newKeyFactory().setKind("keyKind");
+  Key key = keyFactory.newKey("keyName");
+  Entity entity = datastore.get(key);
+  if (entity != null) {
+    System.out.println("Updating access_time for " + entity.getString("name"));
+    entity = Entity.newBuilder(entity)
+        .set("access_time", DateTime.now())
+        .build();
+    datastore.update(entity);
+  }
+  ```
+
+  The complete source code can be found at
+  [UpdateEntity.java](../../google-cloud-examples/src/main/java/com/google/cloud/examples/datastore/snippets/UpdateEntity.java).
+
+  #### Complete source code
+
+  In
+  [AddEntitiesAndRunQuery.java](../../google-cloud-examples/src/main/java/com/google/cloud/examples/datastore/snippets/AddEntitiesAndRunQuery.java)
+  we put together all the code to store data and run queries into one program. The program assumes that you are
+  running on Compute Engine or from your own desktop. To run the example on App Engine, simply move
+  the code from the main method to your application's servlet class and change the print statements to
+  display on your webpage.
+
+  Testing
+  -------
+
+  This library has tools to help write tests for code that uses the Datastore.
+
+  See [TESTING.md](https://github.com/googleapis/google-cloud-java/blob/master/TESTING.md#testing-code-that-uses-datastore) to read more about testing.
+
+  Example Applications
+  --------------------
+  - [`Bookshelf`](https://github.com/GoogleCloudPlatform/getting-started-java/tree/master/bookshelf) - An App Engine app that manages a virtual bookshelf.
+    - This app uses `google-cloud` to interface with Cloud Datastore and Cloud Storage. It also uses Cloud SQL, another Google Cloud Platform service.
+  - [`Flexible Environment/Datastore example`](https://github.com/GoogleCloudPlatform/java-docs-samples/tree/master/flexible/datastore) - A simple app that uses Cloud Datastore to list the last 10 IP addresses that visited your site.
+  - [`SparkDemo`](https://github.com/GoogleCloudPlatform/java-docs-samples/blob/master/flexible/sparkjava) - An example of using `google-cloud-datastore` from within the SparkJava and App Engine Flexible Environment frameworks.
+    - Read about how it works on the example's [README page](https://github.com/GoogleCloudPlatform/java-docs-samples/tree/master/flexible/sparkjava#how-does-it-work).

.repo-metadata.json

@@ -10,5 +10,6 @@
   "repo_short": "java-datastore",
   "distribution_name": "com.google.cloud:google-cloud-datastore",
   "codeowner_team": "@googleapis/firestore-dpe",
-  "api_id": "datastore.googleapis.com"
+  "api_id": "datastore.googleapis.com",
+  "api_description": "is a fully managed, schemaless database for\nstoring non-relational data. Cloud Datastore automatically scales with\nyour users and supports ACID transactions, high availability of reads and\nwrites, strong consistency for reads and ancestor queries, and eventual\nconsistency for all other queries."
 }