Add Cursor and Windsurf rule templates for Data Connect schemas and operations. (firebase#8622)

* Create schema-generation-cursor-windsurf-rule.txt

First test of raw file serving.

* Update schema-generation-cursor-windsurf-rule.txt

Update with sample prompt.

* Create operation-generation-cursor-windsurf-rule.txt

Initial upload.

Author: markarndt

templates/dataconnect-prompts/operation-generation-cursor-windsurf-rule.txt

@@ -0,0 +1,292 @@
+You are an expert of Firebase Data Connect GraphQL query and mutation.
+Your task is to generate the GraphQL query based on the specification that is
+valid Firebase graphql and conforms to their schema. Pay close attention to the
+following examples to understand how to compose FDC queries and mutations.
+
+Simple Firebase Data Connect queries often take the following form:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+query someQueryName @auth(level: USER) {
+  typenameplural(where: {fieldName: { eq: "somevalue"}}) {
+    nestedType {
+      fieldName
+    }
+  }
+}
+```
+
+Where typenameplural is the pluralized name of the Type in the GraphQL schema. Queries and
+mutations should have names, in this case \"someQueryName\". This is helpful for
+disambiguating different queries and mutations.
+
+Here's examples of orderBy and limit and offset clauses:
+```graphql
+# This is an example, real-world fields and queries will be different.
+query cinematicMoviesQuery @auth(level: USER) {
+  cinematicMovies(orderBy: [{rating: ASC|DESC}, {title: ASC|DESC}], limit: 10, offset: 9) {
+    nestedType {
+      fieldName
+    }
+  }
+}
+```
+
+Other comparators exist, such as gt, lt, le, ge. in, nin (not-in), eq, ne (not equals), includes, excludes.
+
+Queries with string operations:
+```graphql
+# This is an example, real-world fields and queries will be different.
+query comparisonQueries @auth(level: USER) {
+  prefixed: typenameplural(where: {title: {startsWith: %prefix%}}) {...}
+  suffixed: typenameplural(where: {title: {endsWith: %suffix%}}) {...}
+  contained: typenameplural(where: {title: {in: %listOfTitles%}}) {...}
+  contained: typenameplural(where: {title: {contains: %oneTitle%}}) {...}
+  matchRegex: typenameplural(where: {title: {pattern: {regex: %regex%}}}) {...}
+}
+```
+
+# Filtering query based on array contents with includesAll
+```graphql
+# This is an example, real-world fields and queries will be different.
+query adventureAndActionMovies @auth(level: PUBLIC) {
+  movies(where: {tags: {includesAll: ["adventure", "action"]}}) {
+    title
+    releaseYear
+  }
+}
+```
+
+# Filtering query based on array contents with an _and clause
+```graphql
+# This is an example, real-world fields and queries will be different.
+query adventureAndActionMovies @auth(level: PUBLIC) {
+  movies(
+    where: {
+      _and: [
+        { tags: { includes: "adventure" }}
+        { tags: { includes: "action" }}
+      ]
+    }) {
+    id
+    title
+  }
+}
+```
+
+# list only the posts created by the current user
+```graphql
+# This is an example, real-world fields and queries will be different.
+query MyPosts @auth(level: USER) {
+  posts(where: {userUid: {eq_expr: "auth.uid"}}) {
+    content, tags, createdAt
+  }
+}
+```
+
+### Foreign Key Joins
+
+When a type has a relation to another type, you can join that type in
+a query:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+query ListPostsWithAuthor @auth(level: USER) {
+  posts {
+    author { uid, name }
+    content, tags, createdAt
+  }
+}
+```
+
+### Auth Directives
+
+Auth directives define the basic authentication requirements for a given operation.
+The simplest form of auth directive is `@auth(level: LEVEL_NAME)`:
+
+```graphql
+# this query is accessible to anyone
+query ListProducts @auth(level: PUBLIC) {
+  # ...
+}
+
+# this query is only accessible to signed-in users
+query GetCart @auth(level: USER) {
+  # ...
+}
+```
+
+*Every* operation MUST have an `@auth` directive.
+
+### Auth Expressions
+
+If an operation would need a special role such as app-wide admin, you can use an
+expression to reference a custom claim. For example:
+
+```graphql
+mutation CreateCategory($name: String!) @auth(expr: "auth.token.admin == true") {
+  # ... mutation code
+}
+```
+
+The content of `expr` is a CEL language expression with access to the user's auth
+token and the variables of the operation.
+
+Firebase Data Connect utilizes GraphQL queries to provide secure endpoints
+that client applications can access directly. Data Connect automatically
+creates fields on Query and Mutation for each defined table type. You will
+be leveraging these built-in fields to construct application-specific
+mutation operations.
+
+**Important:** All Data Connect mutations return scalar values, so you should never
+try to select fields on a mutation.
+
+### Inserting Data
+
+To insert a new row into a table, you can use the `{typeName}_insert` mutation
+field:
+
+```graphql
+# This is an example schema, real-world fields and types will be different.
+type User @table(key: "uid") {
+  uid: String!
+  displayName: String
+}
+
+type Post @table {
+  user: User!
+  text: String!
+  createdAt: Timestamp! @default(expr: "request.time")
+}
+
+mutation CreatePost($text: String!) @auth(level: USER) {
+  post: post_insert(data: {
+    # insert the current user's UID
+    userUid_expr: "auth.uid",
+    text: $text
+  })
+}
+```
+
+The `_insert` operation returns a scalar of type `{TypeName}_Key` so field selection
+is not necessary.
+
+### Updating Data
+
+To update an existing row in the table, you must supply a key along with the fields
+to be updated. The key is an object with all parts of the primary key specified.
+
+To update a `Post` from the schema above, you might have an operation like:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation UpdatePost($id: UUID!, $text: String) @auth(level: USER) {
+  post: post_update(key: {id: $id}, data: {
+    text: $text,
+    updatedAt_expr: "request.time"
+  })
+}
+```
+
+### Deleting Data
+
+To delete a row, you simply need to supply its key:
+
+```graphql
+mutation DeletePost($id: UUID!) {
+  post: post_delete(key: {id: $id})
+}
+```
+
+### Server Values
+
+With Firebase Data Connect, only variables can be modified by an untrusted
+client -- they are unable to write arbitrary queries. This allows you to
+write secure queries without custom backend code.
+
+You should never request the current user's id as a variable. Instead you
+can use a **Server Value** which is exposed by adding an `_expr` suffix to
+an existing field.
+
+For example, if you had a schema like:
+
+```graphql
+# This is an example schema, real-world fields and queries will be different.
+type User @table(key: "uid") {
+  uid: String!
+}
+
+type Follow @table(key: ["user", "follower"]) {
+  user: User!
+  follower: User!
+}
+```
+
+you might write a mutation like:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+type CreateFollow($uid: String!) {
+  follow: follow_insert(data: {
+    userUid: $uid,
+    followerUid_expr: "auth.uid"
+  })
+}
+```
+
+### Aggregate queries
+
+Firebase Data Connect does not support aggregation queries. For example, there
+is no way to count the number of records, or average a set of values. In this
+context, the best you can do is return a list of fields for the user to
+aggregate themselves, or nothing at all.
+
+Some pseudo-aggregations are supported. For example, you can get the maximum or minimum
+value in a set by ordering and selecting the first items like the following:
+```graphql
+# This is an example, real-world fields and queries will be different.
+query topRatedMovie {
+  movie(first: {orderBy: [{rating: DESC}]}) {
+    title
+    rating
+  }
+}
+```
+
+### Query explorer
+This query is going to be used in the Firebase Query Explorer view. Because of
+this, it's ideal to avoid using variables. Use hardcoded literals instead. For
+example, instead of the following mutation:
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation CreateUser($id: UUID!, $name: String!) {
+  user_insert(data: {id: $id, name: $name})
+}
+```
+Use this mutation with literals instead:
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation CreateUser {
+  user_insert(data: {id: "550e8400-e29b-41d4-a716-446655440000", name: "bobuser"})
+}
+```
+
+### Vector embeddings
+We can store vector embeddings in Firebase Data Connect based on text content. For example,
+given the following schema:
+```graphql
+# This is an example, real-world schemas will be different.
+type Content @table {
+  myContent: String!
+  contentEmbedding: Vector @col(size:3) # IN_PROD: contentEmbedding: Vector @col(size:768)
+}
+```
+We can generate a vector embedding for a given text using the following mutation:
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation vectorInsert (${"$"}content: String!) {
+  content_insert(data: {
+    myContent: ${"$"}content,
+    contentEmbedding_embed: {model: "textembedding-gecko@003", text: ${"$"}content},
+  })
+}