feat(sdk): add toResolverOutput function for TailorDBType conversion

toResolverOutput() converts a TailorDBType to a resolver output type
that matches the TailorDB auto-generated query's return type.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: toiroakr

.changeset/funny-planes-admire.md

@@ -0,0 +1,8 @@
+---
+"@tailor-platform/sdk": minor
+---
+
+Add `toResolverOutput` function to convert TailorDBType to resolver output field
+
+- `toResolverOutput(type)` converts a TailorDBType to generated query output type
+- Simplifies using TailorDB types as resolver outputs with proper type names

packages/sdk/docs/services/resolver.md

@@ -120,6 +120,62 @@ createResolver({
 });
 ```
 
+## Custom Type Names
+
+### Using `typeName()` for nested objects
+
+When defining nested objects in input or output schemas, you can specify a custom GraphQL type name using the `typeName()` method. This is useful when you want to control the exact type name that appears in the GraphQL schema.
+
+```typescript
+createResolver({
+  name: "createProfile",
+  operation: "mutation",
+  input: {
+    profile: t
+      .object({
+        name: t.string(),
+        email: t.string(),
+      })
+      .typeName("ProfileInput"), // GraphQL type will be "ProfileInput"
+  },
+  body: (context) => context.input.profile,
+  output: t
+    .object({
+      name: t.string(),
+      email: t.string(),
+    })
+    .typeName("ProfileOutput"), // GraphQL type will be "ProfileOutput"
+});
+```
+
+Without `typeName()`, the SDK generates type names automatically (e.g., `CreateProfileProfile` for input).
+
+### Using `toResolverOutput()` for TailorDB types
+
+`toResolverOutput()` makes the resolver's output type match the TailorDB auto-generated query's return type. For example, if you have a `User` type in TailorDB, `toResolverOutput(user)` produces the same GraphQL type as the auto-generated `user` and `users` queries.
+
+```typescript
+import { createResolver, t, toResolverOutput } from "@tailor-platform/sdk";
+import { user } from "../tailordb/user";
+
+export default createResolver({
+  name: "getUser",
+  operation: "query",
+  input: {
+    id: t.uuid(),
+  },
+  body: async (context) => {
+    const db = getDB("tailordb");
+    return await db
+      .selectFrom("User")
+      .selectAll()
+      .where("id", "=", context.input.id)
+      .executeTakeFirstOrThrow();
+  },
+  output: toResolverOutput(user), // Same type as TailorDB's `user` query returns
+});
+```
+
 ## Input Validation
 
 Add validation rules to input fields using the `validate` method:

packages/sdk/src/configure/services/resolver/index.ts

@@ -1,4 +1,4 @@
-export { createResolver } from "./resolver";
+export { createResolver, toResolverOutput } from "./resolver";
 
 export type {
   QueryType,

packages/sdk/src/configure/services/resolver/resolver.ts

@@ -1,4 +1,5 @@
 import { t } from "@/configure/types/type";
+import type { TailorDBType, TailorAnyDBField } from "@/configure/services/tailordb/schema";
 import type { TailorAnyField, TailorUser } from "@/configure/types";
 import type { TailorEnv } from "@/configure/types/env";
 import type { InferFieldsOutput, output } from "@/configure/types/helpers";
@@ -78,3 +79,18 @@ export function createResolver<
 // A loose config alias for userland use-cases
 // oxlint-disable-next-line no-explicit-any
 export type ResolverConfig = ReturnType<typeof createResolver<any, any>>;
+
+/**
+ * Convert a TailorDBType to a TailorField for use as resolver output.
+ * Equivalent to: t.object(type.fields).typeName(type.name)
+ * @param type - The TailorDBType to convert
+ * @returns A TailorField with the type's fields and name as typeName
+ */
+export function toResolverOutput<Fields extends Record<string, TailorAnyDBField>>(
+  type: TailorDBType<Fields>,
+): TailorField<{ type: "nested"; array: false; typeName: true }, InferFieldsOutput<Fields>> {
+  return t.object(type.fields).typeName(type.name) as TailorField<
+    { type: "nested"; array: false; typeName: true },
+    InferFieldsOutput<Fields>
+  >;
+}