Object relation doesn't compile to TypeScript

M

martinsos•3/12/24, 5:44 PM

Hm @david.fejes this is quite peculiar! We did quite same changes in 0.12, but I don't think we introduced a regression like this on purpose, if that is indeed what it is.
@miho and @Filip will know more about this specific feature so I am pinging them!

M

martinsos•3/12/24, 5:44 PM

https://tenor.com/bfHkc.gif

Tenor

M

miho•3/12/24, 6:15 PM

When i try to display products for material error occurs: Property 'products' does not exist on type 'GetResult<{ id: number; code: string; name: string; count: number; measurementUnit: string; }, unknown> & {}'.

Howdy

Could you please share your actions / queries code? Only the Prisma related parts if you don't want to share everything.

I have found a previous post and solution which includes creating a new type. Is there any way to include objects with types from prisma/entities?

Could you please link the post?

Mmiho > When i try to display products for material error occurs: Property 'products'...

D

david.fejesOP•3/12/24, 8:23 PM

Since im overriding CRUD i have created function in tasks.js

export const getMaterials: Materials.GetAllQuery<void, Material[]> = async (args, context) => {
  const { Material } = context.entities;

  return await Material.findMany({
    include: {
      products: {
        include: {
          product: true,
        },
      },
    },
  });
};

export const getMaterials: Materials.GetAllQuery<void, Material[]> = async (args, context) => {
  const { Material } = context.entities;

  return await Material.findMany({
    include: {
      products: {
        include: {
          product: true,
        },
      },
    },
  });
};

export const getMaterials: Materials.GetAllQuery<void, Material[]> = async (args, context) => {
  const { Material } = context.entities;

  return await Material.findMany({
    include: {
      products: {
        include: {
          product: true,
        },
      },
    },
  });
};

export const getMaterials: Materials.GetAllQuery<void, Material[]> = async (args, context) => {
  const { Material } = context.entities;

  return await Material.findMany({
    include: {
      products: {
        include: {
          product: true,
        },
      },
    },
  });
};

Here is github link: https://github.com/fejes99/MaterialPlanningApp/blob/main/src/materials/operations/tasks.ts

GitHub

MaterialPlanningApp/src/materials/operations/tasks.ts at main · fej...

Contribute to fejes99/MaterialPlanningApp development by creating an account on GitHub.

M

MEE6•3/12/24, 8:23 PM

Wohooo @david.fejes, you just became a Waspeteer level 1!

Mmiho > When i try to display products for material error occurs: Property 'products'...

D

david.fejesOP•3/12/24, 8:25 PM

Here is a link to the post: 🙋questions[SOLVED] Object relation works when running app but doesn't compile to TypeScript?

M

miho•3/13/24, 8:08 AM

So this is an issue with full-stack type safety here

We use the type you annotated the function with to give you types on the client.
-> In your case it was:

Materials.GetAllQuery<void, Material[]>

Materials.GetAllQuery<void, Material[]>

-> This says:

This function will return a list of Material

This function will return a list of Material

(the

Material

Material

type has only its types and not the relationships)

You need to annotate it more precisely since you are not returning only a list of

Material

Material

but also including the relations which change the type.

The way to do this would be to do:

Materials.GetAllQuery<void, (Material & { products: (ProductMaterials & { product: Product })[] })[]>

Materials.GetAllQuery<void, (Material & { products: (ProductMaterials & { product: Product })[] })[]>

You see, I'm now combing the basic

Material

Material

type with the

ProductMaterials

ProductMaterials

and

Product

Product

at places where we have the included relationships.

I know this is annoying! The better behaviour would be to automatically infer the right type and not make you define this complex type.

M

miho•3/13/24, 8:13 AM

I've noted this future improvement in this issue: https://github.com/wasp-lang/wasp/issues/1884

D

david.fejesOP•3/13/24, 9:45 AM

Thanks!

Mmiho So this is an issue with full-stack type safety here 🙂 We use the type you an...

S

seppulcro•2/19/25, 8:43 PM

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 })[]>;
};

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 })[]>;
};

C

cubub•2/20/25, 1:09 AM

@kapa.ai Not sure If it might related, my usecase is implicit many to many relation, with Task and Tag model (1 Tag can belong to multiple Tasks; and one Task can help multiple Tags). The intelisense show no error but the console log denied to compiled:

[ Wasp ] server/operations/actions/index.ts(150,7): error TS2353: Object literal may only specify known properties, and 'Tag' does not exist in type '{ Task: TaskDelegate<DefaultArgs>; }'.
[ Wasp ] server/operations/actions/index.ts(163,7): error TS2353: Object literal may only specify known properties, and 'Tag' does not exist in type '{ Task: TaskDelegate<DefaultArgs>; }'.
[ Wasp ] server/operations/queries/index.ts(89,7): error TS2353: Object literal may only specify known properties, and 'Tag' does not exist in type '{ Task: TaskDelegate<DefaultArgs>; }'.
[ Wasp ] server/operations/queries/index.ts(102,7): error TS2353: Object literal may only specify known properties, and 'Tag' does not exist in type '{ Task: TaskDelegate<DefaultArgs>; }'.

This is due to 4 queries and actions:

getTasksForTag
getTagsForTask
assignTagToTask
removeTagFromTask

Below is one query:
getTagsForTask:

import { Tag } from 'wasp/entities'
import { type GetTasks } from 'wasp/server/operations'

type GetTagsForTaskPayload = {
taskId: string
}

export const getTagsForTask: GetTasks<GetTagsForTaskPayload, Tag[]> = async ({ taskId }, context) => {
const task = await context.entities.Task.findUnique({
where: { id: taskId },
select: { tags: true },
})
return task?.tags || []
}

Obiviously I have already include it in main.wasp:

query getTagsForTask {
fn: import { getTagsForTask } from "@src/server/queries.ts",
entities: [Task, Tag]
}

Any clues on that? @kapa.ai

C

cubub•2/20/25, 1:14 AM

@kapa.ai can you suggest me with above problem?

K

kapa.ai•2/20/25, 1:14 AM

Let me check the knowledge base for you again. One moment!

K

kapa.ai•2/20/25, 1:14 AM

----------------------
I apologize, but I don't have enough context about the specific problem you're referring to. The knowledge sources provided don't contain any information about a previously mentioned problem. To provide an accurate and helpful answer, I would need more details about the issue you're facing with Wasp.

Could you please provide more information about the problem you're experiencing? This will allow me to search the knowledge sources for relevant information and give you a more targeted response.
----------------------
Note: you can ask me a follow up question by @ mentioning me again

----------------------

K

kapa.ai•2/20/25, 1:14 AM

Sorry @cubub, I seem to be having a bit of trouble. Don't worry though, I've pinged my support and they will try to fix me up! :technologist:

Perhaps try again in 15mins?

Ccubub @kapa.ai Not sure If it might related, my usecase is implicit many to many relat...

G

genyus•2/20/25, 2:13 AM

If your tasks and tags have a many-to-many relationship, there must be a join entity which you'd need to include, but isn't shown here. Can you share the relevant entity definitions?

C

cubub•2/20/25, 2:23 AM

No, i use implicit many to many relation as prisma suggested since there is no extra information need to be stored. It is just a tag for task. I also dont see anywhere in wasp documentation state that we need to use explicit relation

C

cubub•2/20/25, 2:27 AM

And here is the model in schema.prisma:

model Task {
id String @id @default(cuid())
description String
isDone Boolean @default(false)
tags Tag[] @relation("TaskTags") // Many-to-many relation with Tag
}

model Tag {
id String @id @default(cuid())
name String
tasks Task[] @relation("TaskTags") // Many-to-many relation with Task
}

G

genyus•2/20/25, 8:59 AM

Apologies, I assumed you were using explicit relations as that was the approach of the OP.

Reading your query again, you’re using

select: { tags: true }

select: { tags: true }

, but it should be

include: { tags: true }

include: { tags: true }

.

select

select

is for returning specific fields, not including entire relations, which it appears you want to do here.

Prisma Client API | Prisma Documentation

API reference documentation for Prisma Client.

Sseppulcro this should definately be added to the docs ASAP because I was almost giving up ...

M

miho•2/20/25, 9:08 AM

This message was 2 years old and since then we updated the docs

https://wasp.sh/docs/data-model/operations/queries#implementing-queries-in-node (green box)

Queries | Wasp

We'll explain what Queries are and how to use them. If you're looking for a detailed API specification, skip ahead to the API Reference.

S

seppulcro•2/20/25, 2:17 PM

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!

Ggenyus Apologies, I assumed you were using explicit relations as that was the approach ...

C

cubub•2/20/25, 2:21 PM

I have changed as you suggested, but the error log is still the same, so I dont think that is the reason. Other 3 files that cause similar troubles also do not have the "include". Here is my repo: https://github.com/cubu/wasprelations/tree/main/src/api/v1/modules/tags

GitHub

wasprelations/src/api/v1/modules/tags at main · cubu/wasprelations

Contribute to cubu/wasprelations development by creating an account on GitHub.

M

MEE6•2/20/25, 2:21 PM

Wohooo @cubub, you just became a Waspeteer level 3!

Ccubub I have changed as you suggested, but the error log is still the same, so I dont ...

G

genyus•2/20/25, 4:34 PM

Thanks for sharing your repo, made it easier to debug. I've raised a PR, but for visibility, the root cause was that you were using the wrong operations in your functions, e.g.:

export const assignTagToTask: UpdateTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

export const assignTagToTask: UpdateTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

export const assignTagToTask: UpdateTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

export const assignTagToTask: UpdateTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

instead of:

export const assignTagToTask: AssignTagToTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

export const assignTagToTask: AssignTagToTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

export const assignTagToTask: AssignTagToTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

export const assignTagToTask: AssignTagToTask<AssignTagToTaskPayload, Task> = async (
  { taskId, tagId },
  context
)

This might've been a copy-and-paste issue, but reusing operations like this isn't valid.

While not an error, you were also importing unused entities, which I removed. You only need to declare an entity in

main.wasp

main.wasp

if you need to execute a db operation on it in your function. The entity isn't required if you're just returning another type through a relation.

M

MEE6•2/20/25, 4:34 PM

Wohooo @genyus, you just became a Waspeteer level 6!

C

cubub•2/21/25, 12:11 AM

Wow! it works perfectly. Thank you very much for your support @genyus .
Turn out I made the action markTaskAsDone and query getFilteredTask by using wrong operations (updateTask and getTasks). But it still works as normal so I think that is the direction to go.
I must careful next time.

Ccubub Wow! it works perfectly. Thank you very much for your support @genyus . Turn out...

G

genyus•2/21/25, 12:15 AM

No problem, you're welcome

S

seppulcro•2/24/25, 10:29 PM

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 })[] })[]
  >;
};

//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>
    ))
  })

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; }'.

S

seppulcro•2/24/25, 10:31 PM

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 })[] })[]
  >;
};

//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>
    ))
  })

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; }'.

S

seppulcro•2/24/25, 10:32 PM

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>
    ))
  })

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

M

MEE6•2/24/25, 10:32 PM

Wohooo @seppulcro, you just became a Waspeteer level 2!

S

seppulcro•2/24/25, 10:34 PM

Is this by design, a bug or have I missed something in the docs again?

@miho @kapa.ai

K

kapa.ai•2/24/25, 10:34 PM

Let me check the knowledge base for you again. One moment!

K

kapa.ai•2/24/25, 10:34 PM

----------------------
I apologize, but I don't have enough context to determine what specific issue or behavior you're referring to. The knowledge sources provided don't contain any information about a particular problem or design decision that matches your question.

To provide an accurate and helpful answer, I would need more details about what you're experiencing with Wasp. Could you please provide more information about:

What specific behavior or feature you're observing?
What you expected to happen instead?
Any error messages or unexpected results you're seeing?

Once you provide more context, I'll be able to search the knowledge sources for relevant information and give you a more targeted response about whether it's by design, a bug, or something that might be explained in the documentation.

If you're referring to a specific part of the Wasp framework or a particular feature, please let me know, and I'll do my best to address your concern based on the available information.
----------------------
Note: you can ask me a follow up question by @ mentioning me again

----------------------

K

kapa.ai•2/24/25, 10:34 PM

Sorry @seppulcro, I seem to be having a bit of trouble. Don't worry though, I've pinged my support and they will try to fix me up! :technologist:

Perhaps try again in 15mins?

S

seppulcro•2/24/25, 10:37 PM

@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 })[] })[]
  >;
};

//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>
    ))
  })

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; }'.

K

kapa.ai•2/24/25, 10:37 PM

Let me check the knowledge base for you again. One moment!

K

kapa.ai•2/24/25, 10:37 PM

----------------------
Based on the information provided in the knowledge sources and your question, it appears that you're encountering an issue with type inference for explicit many-to-many relationships in Wasp. This behavior is likely not by design and might be a limitation or bug in the current implementation of Wasp's type generation system.

The problem you're experiencing is similar to an issue discussed in a Discord support thread. According to 🙋questionsObject relation doesn't compile to TypeScript, there's a known issue with full-stack type safety in Wasp, particularly when dealing with relations.

The core of the problem seems to be that the type annotation you're using for the query doesn't fully capture the structure of the data you're returning, especially for the related entities.

Here's what's happening:

You're using

GetAllUsers<void, (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]>

GetAllUsers<void, (User & { processes: (ProcessesOnUsers & { process: Process })[] })[]>

as the type annotation for your query.

This type correctly includes the
```
processes
```
```
processes
```
field, but it doesn't explicitly include the
```
assignedBy
```
```
assignedBy
```
and
```
assignedAt
```
```
assignedAt
```
fields from the
```
ProcessesOnUsers
```
```
ProcessesOnUsers
```
model.
As a result, when you try to access
```
process.assignedBy
```
```
process.assignedBy
```
in your React component, TypeScript doesn't recognize this property.

A community member from Wasp (Community Member 1) suggested a workaround for a similar issue:

"You need to annotate it more precisely since you are not returning only a list of

Material

Material

but also including the relations which change the type."

Applying this advice to your case, you might need to modify your type annotation to explicitly include all the fields you're selecting in your query. Something like this:

K

kapa.ai•2/24/25, 10:37 PM

GetAllUsers<
  void,
  (User & { 
    processes: (ProcessesOnUsers & { 
      process: Process,
      assignedBy: string, // or whatever the correct type is
      assignedAt: Date 
    })[] 
  })[]
>

GetAllUsers<
  void,
  (User & { 
    processes: (ProcessesOnUsers & { 
      process: Process,
      assignedBy: string, // or whatever the correct type is
      assignedAt: Date 
    })[] 
  })[]
>

GetAllUsers<
  void,
  (User & { 
    processes: (ProcessesOnUsers & { 
      process: Process,
      assignedBy: string, // or whatever the correct type is
      assignedAt: Date 
    })[] 
  })[]
>

GetAllUsers<
  void,
  (User & { 
    processes: (ProcessesOnUsers & { 
      process: Process,
      assignedBy: string, // or whatever the correct type is
      assignedAt: Date 
    })[] 
  })[]
>

This issue has been noted for improvement in this GitHub issue. The Wasp team acknowledges that the current behavior is annoying and that a better solution would be to automatically infer the right type without requiring such complex manual type definitions.

In conclusion, this appears to be a limitation in the current version of Wasp rather than an intended design. The Wasp team is aware of this issue and is working on improving the type inference for these scenarios. For now, you'll need to use more explicit type annotations as a workaround.
----------------------
Note: you can ask me a follow up question by @ mentioning me again

----------------------

K

kapa.ai•2/24/25, 10:37 PM

Sorry @seppulcro, I seem to be having a bit of trouble. Don't worry though, I've pinged my support and they will try to fix me up! :technologist:

Perhaps try again in 15mins?

S

seppulcro•2/24/25, 10:41 PM

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>
    ))
  })

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

K

kapa.ai•2/24/25, 10:41 PM

Let me check the knowledge base for you again. One moment!

K

kapa.ai•2/24/25, 10:42 PM

----------------------
Based on the information provided in the knowledge sources and our previous conversation, it appears that the behavior you're experiencing is related to how Wasp handles type generation for relations, particularly for explicit many-to-many relationships.

To answer your questions:

Regarding implicit relations in Prisma schema:The knowledge sources don't provide specific information about how Wasp handles implicit relations in Prisma schema. Therefore, I can't confidently say whether implicit relations would automatically include the relationship fields or if they would also require manual addition.
Automatically adding relationships when using imports from "wasp/entities":Currently, there doesn't seem to be a way to automatically add the relationship fields when importing types from "wasp/entities". The issue you're experiencing is related to a known limitation in Wasp's type inference system.

As mentioned in our previous conversation, this behavior is not ideal and has been acknowledged by the Wasp team. They have noted this for improvement in this GitHub issue.

The current workaround, as you've discovered, is to manually specify the types using the junction table type (ProcessesOnUsers in your case). This approach correctly types the fields from your many-to-many relationship.

It's worth noting that the Wasp team is aware of these type inference issues and is working on improving them. As stated by a Wasp team member in 🙋questionsObject relation doesn't compile to TypeScript:

"I know this is annoying! The better behaviour would be to automatically infer the right type and not make you define this complex type."

K

kapa.ai•2/24/25, 10:42 PM

For now, the most reliable approach is to continue using explicit type annotations as you've done with

ProcessesOnUsers

ProcessesOnUsers

. This ensures that TypeScript recognizes all the fields in your relations.

If you need further clarification or have more specific questions about Wasp's handling of Prisma relations and type generation, it might be helpful to reach out to the Wasp team directly through their Discord channel or by creating a GitHub issue.
----------------------
Note: you can ask me a follow up question by @ mentioning me again

----------------------

K

kapa.ai•2/24/25, 10:42 PM

Sorry @seppulcro, I seem to be having a bit of trouble. Don't worry though, I've pinged my support and they will try to fix me up! :technologist:

Perhaps try again in 15mins?

Sseppulcro Unless I manually define it using my junction table type such as ```typescript i...

G

genyus•2/25/25, 1:28 AM

This is the correct type and implementation for your model.

Your original attempt fails because

user.processes

user.processes

isn’t a collection of

Process

Process

objects as you’re expecting it to be, it’s a collection of

ProcessesOnUsers

ProcessesOnUsers

objects and the compiler rightly complains that

assignedBy

assignedBy

doesn’t exist on the

Process

Process

type.

Remember that the

assignedBy

assignedBy

column lives in your junction table, so that's where the property must be referenced from. If you needed to access the actual

Process

Process

objects, then you could do something like:

return user.processes.map((userProcess: ProcessesOnUsers, index) => (
      <span>{userProcess.process.name}</span>
      <p>{userProcess.process.description}</p>
    ))
  })

return user.processes.map((userProcess: ProcessesOnUsers, index) => (
      <span>{userProcess.process.name}</span>
      <p>{userProcess.process.description}</p>
    ))
  })

return user.processes.map((userProcess: ProcessesOnUsers, index) => (
      <span>{userProcess.process.name}</span>
      <p>{userProcess.process.description}</p>
    ))
  })

return user.processes.map((userProcess: ProcessesOnUsers, index) => (
      <span>{userProcess.process.name}</span>
      <p>{userProcess.process.description}</p>
    ))
  })

Ggenyus This is the correct type and implementation for your model. Your original attem...

S

seppulcro•2/25/25, 12:01 PM

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!

M

miho•2/25/25, 2:02 PM

Hey @seppulcro

have you tried typing your query like this:

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
   ...
  }) satisfies GetAllUsers<void>;
};

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
   ...
  }) satisfies GetAllUsers<void>;
};

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
   ...
  }) satisfies GetAllUsers<void>;
};

export const getAllUsers = async (_args, context) => {
  return context.entities.User.findMany({
   ...
  }) satisfies GetAllUsers<void>;
};

(drop the second type param for

GetAllUsers

GetAllUsers

type)

This should allow TS to use the return type of

getAllUsers

getAllUsers

as the output of the query

Mmiho Hey @seppulcro have you tried typing your query like this: ```ts export const ...

S

seppulcro•2/25/25, 9:58 PM

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

Sseppulcro Same issue sadly > error TS2339: Property 'assignedBy' does not exist on type '{...

G

genyus•2/25/25, 11:03 PM

Ah, so I think the problem now is that you’re explicitly typing your query results instead of allowing Typescript to infer them — and you’re hiding the relation properties as a result. Try this in combination with @miho’s suggestion above:

users.map((user)=>{
    return user.processes.map((process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

users.map((user)=>{
    return user.processes.map((process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

users.map((user)=>{
    return user.processes.map((process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })

users.map((user)=>{
    return user.processes.map((process, index) => (
      <span>{process.assignedBy}</span>
    ))
  })