seppulcro Comments - Answer Overflow

seppulcro

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Which now allows me to do use

  const { data: processes, isLoading, error } = useQuery(getAllProcesses);

  const { data: processes, isLoading, error } = useQuery(getAllProcesses);

and now I can do stuff like

  const renderCell = useCallback(
    (process: (typeof processes), columnKey) => {

  const renderCell = useCallback(
    (process: (typeof processes), columnKey) => {

and processes is typed such as

const processes: ({
    id: number;
    name: string;
    description: string | null;
    createdAt: Date;
    updatedAt: Date;
} & {
    users: (ProcessesOnUsers & {
        user: User;
    })[];
    models: (ModelsOnProcesses & {
        model: Model;
    })[];
})[] | undefined

const processes: ({
    id: number;
    name: string;
    description: string | null;
    createdAt: Date;
    updatedAt: Date;
} & {
    users: (ProcessesOnUsers & {
        user: User;
    })[];
    models: (ModelsOnProcesses & {
        model: Model;
    })[];
})[] | undefined

process.users.map()

process.users.map()

Is now correctly infered, or can be explicitely typed with

process.users.map(({ user }: { user: User }, index)

process.users.map(({ user }: { user: User }, index)

Without any errors! I think the main issue boiled down to

process:Process
---should be---
process:ProcessWithRelations

process:Process
---should be---
process:ProcessWithRelations

But this validates my point that Wasp does not generate types with relations, but can be correctly infered via TS? 😛 Solution is just not try and use explicit types and trust TS

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Hey! Sorry had a pretty crazy week at work. Just picked this up again and it really seems that wasp is not generating types with relations in them, just the simplified version

(alias) type Process = {
    id: number;
    name: string;
    description: string | null;
    createdAt: Date;
    updatedAt: Date;
}
import Process
Model Process

(alias) type Process = {
    id: number;
    name: string;
    description: string | null;
    createdAt: Date;
    updatedAt: Date;
}
import Process
Model Process

this is the definiton of process, that's why TS is complaining, tried db reset, wasp clean, everything... 😄

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Yeah you're right! When going with @miho simplified approach and If I dont explicitly type the query results as you've suggested, wasp no longers throws the compiler error! All that happens now is a tsc linter error

Parameter 'process' implicitly has an 'any' type.ts(7006)

But the project compiles and runs fine 🙂 Thanks for the suggestions guys, is this the advised approach I should go for moving forward? Would also love some more insight on why this happens and how I could possibly avoid the linter error, or if It's better to just ignore it.

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Same issue sadly

error TS2339: Property 'assignedBy' does not exist on type '{ id: number; name: string; description: string | null; createdAt: Date; updatedAt: Date; }'.

only way it seems to work is via the approach described above and re-iterated by @genyus

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Yeah I figured as much! I But the question I has was if this was happening because I was using explicit relations, or is this the same case in implicit relations? Also just out of pure tech curiosity, is this a limitation on wasp type generation or a general type inference generation issue? Because from my limited understanding of typescript, if these were types defined exactly as the model is it is able to know hich property the nested object type has, right? I understand that the fact that wasp is probably generating operation types based of the generated model, which can make this way trickier. This could also mean that maybe I'm not importing the types from the correct place? Really enjoying using it so far, but I'm learning multiple new technologies at the same time and I might be confusing things Thanks for the feedback!

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Unless I manually define it using my junction table type such as

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: **ProcessesOnUsers**, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: **ProcessesOnUsers**, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

which makes the error go away 🙂 Do implicit relations for prisma.schema also need relationship manually added? Or is there some way to infer when we generate them them when using

import {
  type Process,
  type User,
} from "wasp/entities";

import {
  type Process,
  type User,
} from "wasp/entities";

@kapa.ai

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

@kapa.ai Does the Wasp type generation currently not automatically infer the fields of related models when you use explicit many-to-many relationships, only for implicit? Process and Users have an explicitly declared relation in prisma.schema

//src/queries/users.ts
import { Process, ProcessesOnUsers, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

// src/queries/users.ts

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
    include: {
      processes: {
        select: {
          assignedBy: true, // Explicitly include missing fields
          assignedAt: true, // Explicitly include missing fields
          process: true, // Make sure `process` is still included
        },
      },
    },
  }) satisfies GetAllUsers<
    void,
    (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]
  >;
};

//src/queries/users.ts
import { Process, ProcessesOnUsers, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

// src/queries/users.ts

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
    include: {
      processes: {
        select: {
          assignedBy: true, // Explicitly include missing fields
          assignedAt: true, // Explicitly include missing fields
          process: true, // Make sure `process` is still included
        },
      },
    },
  }) satisfies GetAllUsers<
    void,
    (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]
  >;
};

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: Process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: Process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

Produces

error TS2339: Property 'assignedBy' does not exist on type '{ id: number; name: string; description: string | null; createdAt: Date; updatedAt: Date; }'.

error TS2339: Property 'assignedBy' does not exist on type '{ id: number; name: string; description: string | null; createdAt: Date; updatedAt: Date; }'.

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Is this by design, a bug or have I missed something in the docs again? 💀 @miho @kapa.ai

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Unless I manually define it using my junction table type such as

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: **ProcessesOnUsers**, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: **ProcessesOnUsers**, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

which makes the error go away 🙂

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

Instead of openin a new thread I'll use this one since it already has valuble information on this topic Does the Wasp type generation currently not automatically infer the fields of related models when you use explicit many-to-many relationships, only for implicit? My schema is currently using explicit junction tables as per Prisma docs here: https://www.prisma.io/docs/orm/prisma-schema/data-model/relations/many-to-many-relations#querying-an-explicit-many-to-many I'm asking because even when defining query as such

//src/queries/users.ts
import { Process, ProcessesOnUsers, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

// src/queries/users.ts

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
    include: {
      processes: {
        select: {
          assignedBy: true, // Explicitly include missing fields
          assignedAt: true, // Explicitly include missing fields
          process: true, // Make sure `process` is still included
        },
      },
    },
  }) satisfies GetAllUsers<
    void,
    (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]
  >;
};

//src/queries/users.ts
import { Process, ProcessesOnUsers, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

// src/queries/users.ts

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
    include: {
      processes: {
        select: {
          assignedBy: true, // Explicitly include missing fields
          assignedAt: true, // Explicitly include missing fields
          process: true, // Make sure `process` is still included
        },
      },
    },
  }) satisfies GetAllUsers<
    void,
    (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]
  >;
};

While the HTTP response is fine on a component when I want to access it in something such as

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: Process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: Process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

I will always get

error TS2339: Property 'assignedBy' does not exist on type '{ id: number; name: string; description: string | null; createdAt: Date; updatedAt: Date; }'.

error TS2339: Property 'assignedBy' does not exist on type '{ id: number; name: string; description: string | null; createdAt: Date; updatedAt: Date; }'.

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

//src/queries/users.ts
import { Process, ProcessesOnUsers, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

// src/queries/users.ts

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
    include: {
      processes: {
        select: {
          assignedBy: true, // Explicitly include missing fields
          assignedAt: true, // Explicitly include missing fields
          process: true, // Make sure `process` is still included
        },
      },
    },
  }) satisfies GetAllUsers<
    void,
    (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]
  >;
};

//src/queries/users.ts
import { Process, ProcessesOnUsers, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

// src/queries/users.ts

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
    include: {
      processes: {
        select: {
          assignedBy: true, // Explicitly include missing fields
          assignedAt: true, // Explicitly include missing fields
          process: true, // Make sure `process` is still included
        },
      },
    },
  }) satisfies GetAllUsers<
    void,
    (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]
  >;
};

While the HTTP response is fine on a component when I want to access it in something such as

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: Process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

import {
  type Process,
  type ProcessesOnUsers,
  type User,
  type Model,
} from "wasp/entities";

  const { data: users, isLoading, error } = useQuery(getAllUsers);
users.map((user:User)=>{
    return user.processes.map((process: Process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

I will always get

error TS2339: Property 'assignedBy' does not exist on type '{ id: number; name: string; description: string | null; createdAt: Date; updatedAt: Date; }'.

error TS2339: Property 'assignedBy' does not exist on type '{ id: number; name: string; description: string | null; createdAt: Date; updatedAt: Date; }'.

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

You are right I would change this to a scary red color and make it vibrate though because I missed it. I don't see a clear message stating that many to many must use these though so if it's your first time (as was mine) using wasp you might have a hard time understanding why your HTTP responses have the relation data in them but your react components don't!

57 replies

WWasp

•Created by david.fejes on 3/12/2024 in #🙋questions

Object relation doesn't compile to TypeScript

this should definately be added to the docs ASAP because I was almost giving up on this after almost two days of not understanding why I had to use any types when trying to map stuff inside entities with many to many relations would this be the correct usage?

import { Process, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

export const getAllUsers = async (_args, context) => {
  return context.entities.U.findMany({
    include: {
      processes: true,
    },
  }) satisfies GetAllUsers<void, (User & { processes: Process })[]>;
};

import { Process, User } from "wasp/entities";
import { type GetAllUsers } from "wasp/server/operations";

export const getAllUsers = async (_args, context) => {
  return context.entities.U.findMany({
    include: {
      processes: true,
    },
  }) satisfies GetAllUsers<void, (User & { processes: Process })[]>;
};

57 replies

WWasp

•Created by seppulcro on 2/15/2025 in #🙋questions

authRequired custom fn

That was the approach I ended up taking, this was just me wondering if there a more flexible way to do it via main.wasp route definitions

18 replies

WWasp

•Created by seppulcro on 2/15/2025 in #🙋questions

Invalid discriminator value. Expected 'development' | 'production'

https://wasp.sh/docs/data-model/backends#writing-a-seed-function createUser

12 replies

WWasp

•Created by seppulcro on 2/15/2025 in #🙋questions

Invalid discriminator value. Expected 'development' | 'production'

 providerData: await sanitizeAndSerializeProviderData({
                hashedPassword: data.password,
              }),

 providerData: await sanitizeAndSerializeProviderData({
                hashedPassword: data.password,
              }),

12 replies

WWasp

•Created by seppulcro on 2/15/2025 in #🙋questions

Invalid discriminator value. Expected 'development' | 'production'

No problem! I'll also update the docs to reflect how to use prisma client for types and or enums set in the schema. Seems like sanitizeAndSerializeProviderData is also not working as expected or maybe the docs are out of date? It needs an await 🙂

12 replies

WWasp

•Created by seppulcro on 2/15/2025 in #🙋questions

Invalid discriminator value. Expected 'development' | 'production'

Welp the AI answer did help, setting a .env.server with NODE_ENV=development
But i cannot for the life of me find any reference to this in the docs?

12 replies

Gaming

Programming