fix publish issue

package/recipes/authorization.md

@@ -0,0 +1,102 @@
+## Authorization
+
+The `createContext`-function is called for each incoming request so here you can add contextual information about the calling user from the request object.
+
+### Create context from request headers
+
+```ts
+// ~/server/trpc/index.ts
+import type { inferAsyncReturnType } from '@trpc/server'
+import type { CompatibilityEvent } from 'h3'
+import { decodeAndVerifyJwtToken } from '~/somewhere/in/your/app/utils'
+
+// The app's context - is generated for each incoming request
+export async function createContext({ req }: CompatibilityEvent) {
+  // Create your context based on the request object
+  // Will be available as `ctx` in all your resolvers
+
+  // This is just an example of something you'd might want to do in your ctx fn
+  async function getUserFromHeader() {
+    if (req.headers.authorization) {
+      const user = await decodeAndVerifyJwtToken(req.headers.authorization.split(' ')[1])
+      return user
+    }
+    return null
+  }
+  const user = await getUserFromHeader()
+
+  return {
+    user,
+  }
+}
+
+type Context = inferAsyncReturnType<typeof createContext>
+
+// [..] Define API handler and app router
+```
+
+### Option 1: Authorize using resolver
+
+```ts
+import { TRPCError } from '@trpc/server'
+
+export const router = trpc
+  .router<Context>()
+  // open for anyone
+  .query('hello', {
+    input: z.string().nullish(),
+    resolve: ({ input, ctx }) => {
+      return `hello ${input ?? ctx.user?.name ?? 'world'}`
+    },
+  })
+  // checked in resolver
+  .query('secret', {
+    resolve: ({ ctx }) => {
+      if (!ctx.user)
+        throw new TRPCError({ code: 'UNAUTHORIZED' })
+
+      return {
+        secret: 'sauce',
+      }
+    },
+  })
+```
+
+### Option 2: Authorize using middleware
+
+```ts
+import * as trpc from '@trpc/server'
+import { TRPCError } from '@trpc/server'
+
+// Merging routers: https://trpc.io/docs/merging-routers
+
+export const router = trpc
+  .router<Context>()
+  // this is accessible for everyone
+  .query('hello', {
+    input: z.string().nullish(),
+    resolve: ({ input, ctx }) => {
+      return `hello ${input ?? ctx.user?.name ?? 'world'}`
+    },
+  })
+  .merge(
+    'admin.',
+    trpc.router<Context>()
+      // this protects all procedures defined next in this router
+      .middleware(async ({ ctx, next }) => {
+        if (!ctx.user?.isAdmin)
+          throw new TRPCError({ code: 'UNAUTHORIZED' })
+
+        return next()
+      })
+      .query('secret', {
+        resolve: ({ ctx }) => {
+          return {
+            secret: 'sauce',
+          }
+        },
+      }),
+  )
+```
+
+Learn more about authorization [here](https://trpc.io/docs/authorization).

package/recipes/error-formatting.md

@@ -0,0 +1,41 @@
+## Error Formatting
+
+The error formatting in your router will be inferred all the way to your client (& Vue components).
+
+### Adding custom formatting
+
+```ts
+// ~/server/trpc/index.ts
+import * as trpc from '@trpc/server'
+
+export const router = trpc.router<Context>()
+  .formatError(({ shape, error }) => {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError:
+          error.code === 'BAD_REQUEST'
+          && error.cause instanceof ZodError
+            ? error.cause.flatten()
+            : null,
+      }
+    }
+  })
+```
+
+### Usage in Vue
+
+```html
+<script setup lang="ts">
+const { error } = await useAsyncQuery(['getUser', { id: 69 }])
+</script>
+
+<template>
+  <pre v-if="error?.data?.zodError">
+    {{ JSON.stringify(error.data.zodError, null, 2) }}
+  </pre>
+</template>
+```
+
+Learn more about error formatting [here](https://trpc.io/docs/error-formatting).

package/recipes/error-handling.md

@@ -0,0 +1,15 @@
+## Handling errors
+
+All errors that occur in a procedure go through the `onError` method before being sent to the client. Here you can handle or change errors.
+
+```ts
+// ~/server/trpc/index.ts
+import * as trpc from '@trpc/server'
+
+export function onError({ error, type, path, input, ctx, req }) {
+  console.error('Error:', error)
+  if (error.code === 'INTERNAL_SERVER_ERROR') {
+    // send to bug reporting
+  }
+}
+```

package/recipes/validation.md

@@ -0,0 +1,49 @@
+## Validation
+
+tRPC works out-of-the-box with yup/superstruct/zod/myzod/custom validators.
+
+### Input Validation
+
+```ts
+// ~/server/trpc/index.ts
+import { z } from 'zod'
+
+export const router = trpc
+  .router()
+  .mutation('createUser', {
+    // validate input with Zod
+    input: z.object({
+      name: z.string().min(5)
+    }),
+    async resolve(req) {
+      // use your ORM of choice
+      return await UserModel.create({
+        data: req.input,
+      })
+    },
+  })
+```
+
+### Output Validation
+
+```ts
+// ~/server/trpc/index.ts
+import { z } from 'zod'
+
+export const router = trpc
+  .router()
+  .query('hello', {
+    // validate output with Zod
+    output: z.object({
+      greeting: z.string()
+    }),
+    // expects return type of { greeting: string }
+    resolve() {
+      return {
+        greeting: 'hello!',
+      }
+    },
+  })
+```
+
+Learn more about input validation [here](https://trpc.io/docs/router#input-validation).