Which docs to follow for cross platform?

W

Wezter•10/9/22, 10:19 AM

Here are the errors I'm currently getting when trying to sign in / sign up right now.

I think I might have done something wrong in my authRouter.

A

Alex / KATT 🐱•10/9/22, 11:52 AM

https://github.com/t3-oss/create-t3-turbo

AAlex / KATT 🐱https://github.com/t3-oss/create-t3-turbo

W

Wezter•10/9/22, 11:55 AM

You mean to use that to look at their tRPC implementation?

That repo sadly doesn't have screen sharing between web and mobile which is the main reason I went with that other starter.

W

Wezter•10/9/22, 12:08 PM

Do you happen to see an issue with what I did regarding the 'me' part at the end that was previously merged?

Before:

export const authRouter = createRouter()
  .mutation('signIn', {
    input: SignInSchema,
    resolve: async ({ input: { email, password } }) => {
      return signIn({ email, password })
    },
  })
  .mutation('signUp', {
    input: SignUpSchema,
    resolve: async ({ input: { email, password } }) => {
      const user = await signUp({ email, password })
      const token = await createSession(user)
      return { token }
    },
  })
  .merge(
    'me',
    protectedRoute.query('', {
      resolve: async ({ ctx }) => {
        return ctx.user
      },
    })
  )

export const authRouter = createRouter()
  .mutation('signIn', {
    input: SignInSchema,
    resolve: async ({ input: { email, password } }) => {
      return signIn({ email, password })
    },
  })
  .mutation('signUp', {
    input: SignUpSchema,
    resolve: async ({ input: { email, password } }) => {
      const user = await signUp({ email, password })
      const token = await createSession(user)
      return { token }
    },
  })
  .merge(
    'me',
    protectedRoute.query('', {
      resolve: async ({ ctx }) => {
        return ctx.user
      },
    })
  )

export const authRouter = createRouter()
  .mutation('signIn', {
    input: SignInSchema,
    resolve: async ({ input: { email, password } }) => {
      return signIn({ email, password })
    },
  })
  .mutation('signUp', {
    input: SignUpSchema,
    resolve: async ({ input: { email, password } }) => {
      const user = await signUp({ email, password })
      const token = await createSession(user)
      return { token }
    },
  })
  .merge(
    'me',
    protectedRoute.query('', {
      resolve: async ({ ctx }) => {
        return ctx.user
      },
    })
  )

export const authRouter = createRouter()
  .mutation('signIn', {
    input: SignInSchema,
    resolve: async ({ input: { email, password } }) => {
      return signIn({ email, password })
    },
  })
  .mutation('signUp', {
    input: SignUpSchema,
    resolve: async ({ input: { email, password } }) => {
      const user = await signUp({ email, password })
      const token = await createSession(user)
      return { token }
    },
  })
  .merge(
    'me',
    protectedRoute.query('', {
      resolve: async ({ ctx }) => {
        return ctx.user
      },
    })
  )

after:

export const authRouter = t.router({
  signIn: t.procedure.input(SignInSchema).mutation((req) => {
    const { input } = req

    return signIn({ email: input.email, password: input.password })
  }),
  signUp: t.procedure.input(SignUpSchema).mutation(async (req) => {
    const input = req.input

    const user = await signUp({ email: input.email, password: input.password })
    const token = await createSession(user)
    return { token }
  }),
  me: t.procedure.use(protectedRoute).query(async (req) => {
    const { ctx } = req
    return ctx.user
  }),
})

export const authRouter = t.router({
  signIn: t.procedure.input(SignInSchema).mutation((req) => {
    const { input } = req

    return signIn({ email: input.email, password: input.password })
  }),
  signUp: t.procedure.input(SignUpSchema).mutation(async (req) => {
    const input = req.input

    const user = await signUp({ email: input.email, password: input.password })
    const token = await createSession(user)
    return { token }
  }),
  me: t.procedure.use(protectedRoute).query(async (req) => {
    const { ctx } = req
    return ctx.user
  }),
})

export const authRouter = t.router({
  signIn: t.procedure.input(SignInSchema).mutation((req) => {
    const { input } = req

    return signIn({ email: input.email, password: input.password })
  }),
  signUp: t.procedure.input(SignUpSchema).mutation(async (req) => {
    const input = req.input

    const user = await signUp({ email: input.email, password: input.password })
    const token = await createSession(user)
    return { token }
  }),
  me: t.procedure.use(protectedRoute).query(async (req) => {
    const { ctx } = req
    return ctx.user
  }),
})

export const authRouter = t.router({
  signIn: t.procedure.input(SignInSchema).mutation((req) => {
    const { input } = req

    return signIn({ email: input.email, password: input.password })
  }),
  signUp: t.procedure.input(SignUpSchema).mutation(async (req) => {
    const input = req.input

    const user = await signUp({ email: input.email, password: input.password })
    const token = await createSession(user)
    return { token }
  }),
  me: t.procedure.use(protectedRoute).query(async (req) => {
    const { ctx } = req
    return ctx.user
  }),
})