SDK build failed with exit code: 2

Heyy @kapa.ai !

[  Wasp  ] ext-src/dashboard/routines/EditRoutineModal.tsx(88,68): error TS2352: Conversion of type 'string' to type 'Set<string>' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.
[  Wasp  ] ext-src/dashboard/routines/RoutineForm.tsx(61,87): error TS2352: Conversion of type 'string' to type 'Set<string>' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.
[  Wasp  ] ext-src/dashboard/routines/RoutinesPage.tsx(36,15): error TS2322: Type '(GetResult<{ id: number; name: string; userId: string; }, unknown> & {})[]' is not assignable to type 'RoutineWithExercises[]'.
[  Wasp  ]   Property 'exercises' is missing in type 'GetResult<{ id: number; name: string; userId: string; }, unknown> & {}' but required in type 'RoutineWithExercises'.

My main.wasp:

// Routine Queries
query getRoutines {
  fn: import { getRoutines } from "@src/dashboard/routines/RoutineQueries",
  entities: [Routine, Exercise]
}

// Routine Actions
action createRoutine {
  fn: import { createRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise]
}

action updateRoutine {
  fn: import { updateRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise]
}

action deleteRoutine {
  fn: import { deleteRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine]
}

// Routine Route
route RoutinesRoute { path: "/routines", to: RoutinesPage }
page RoutinesPage {
  component: import RoutinesPage from "@src/dashboard/routines/RoutinesPage",
  authRequired: true
}

Schema.prisma

model User {
  id        String   @id @default(uuid())
  routines  Routine[] // Relación de uno a muchos con rutinas
}
model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  exercises Exercise[] // Relación muchos-a-muchos con ejercicios
  user      User       @relation(fields: [userId], references: [id])
  userId    String
}

model Exercise {
  id                Int       @id @default(autoincrement())
  name              String
  instructions      String
  difficulty        Difficulty
  equipmentRequired Boolean
  equipment         String?
  bodyPart          BodyPart  @relation(fields: [bodyPartId], references: [id])
  bodyPartId        Int
  routines          Routine[]
}

model BodyPart {
  id        Int        @id @default(autoincrement())
  name      String     @unique  // Nombre de la parte del cuerpo
    description String?    // Añade esta línea
  exercises Exercise[] // Relación uno-a-muchos con ejercicios
}

Where and why do you think this error occurs, how can we solve it? Which code of my project would help you to solve the problem?

35 Replies

kapa.ai•2mo ago

Hi @NEROX. I'm kapa.ai, your friendly support bot. I will try to answer your question by searching through the knowledge base. :wave: ---------------------- The error messages you're seeing are TypeScript type errors. They are occurring because the types of some variables or expressions in your code do not match the expected types. 1. The first two errors are about trying to convert a string to a Set<string>. This is not allowed because these types are not compatible. You should check the code at ext-src/dashboard/routines/EditRoutineModal.tsx line 88 and ext-src/dashboard/routines/RoutineForm.tsx line 61, and make sure you are not trying to assign a string to a variable or parameter that is expected to be a Set<string>. 2. The third error is about a type mismatch between (GetResult<{ id: number; name: string; userId: string; }, unknown> & {})[] and RoutineWithExercises[]. It seems like you're trying to assign the result of a getRoutines query to a variable or parameter of type RoutineWithExercises[], but the types do not match because the exercises property is missing in the query result. You should check the code at ext-src/dashboard/routines/RoutinesPage.tsx line 36, and make sure the result of the getRoutines query includes the exercises property. Unfortunately, without seeing the rest of your code, it's hard to provide more specific advice. However, you should start by checking the mentioned files and lines, and making sure the types of all variables and expressions match their expected types. If you're still having trouble, you might want to consider asking for help on the Wasp Discord server (https://discord.com/channels/686873244791210014/1212533517360177253) or opening an issue on the Wasp GitHub repository (https://github.com/wasp-lang/wasp/issues). ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai Thanks! Now I just have 2 errors:

[  Wasp  ] ext-src/dashboard/routines/EditRoutineModal.tsx(88,52): error TS2352: Conversion of type 'string' to type 'Set<string>' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.
[  Wasp  ] ext-src/dashboard/routines/RoutineForm.tsx(61,75): error TS2352: Conversion of type 'string' to type 'Set<string>' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- The errors you're seeing are TypeScript type errors. They are occurring because you're trying to convert a string to a Set<string>. This is not allowed because these types are not compatible. 1. Check the code at ext-src/dashboard/routines/EditRoutineModal.tsx line 88. You're likely trying to assign a string to a variable or parameter that is expected to be a Set<string>. 2. Similarly, check the code at ext-src/dashboard/routines/RoutineForm.tsx line 61. The same type of error is occurring here. Without seeing the specific lines of code, it's hard to provide a specific solution. However, you'll need to ensure that you're not trying to assign a string to a Set<string>. If you're trying to create a Set<string> with a single string, you can do so like this: new Set([myString]). If you're still having trouble, consider asking for help on the Wasp Discord server (https://discord.com/channels/686873244791210014/1212533517360177253) or opening an issue on the Wasp GitHub repository (https://github.com/wasp-lang/wasp/issues). ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

✅ You did it again my boy🥹 (will this open bc will chat more today) @kapa.ai You solved the problem! Thx, next question: I have in my schema.prisma:

model User {
  id        String   @id @default(uuid())

  routines  Routine[]
}

model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  exercises Exercise[]
  user      User       @relation(fields: [userId], references: [id])
  userId    String
}

The relation is that a routine always needs to be related to a user or more, in this case I would like to be able to have routines without the relation with the user being mandatory, how would you modify those lines of code?

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- To make the relation between Routine and User optional in your Prisma schema, you can make the user and userId fields in the Routine model optional by adding a ? after their types. Here's how you can modify your schema.prisma:

model User {
  id        String   @id @default(uuid())
  routines  Routine[]
}

model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  exercises Exercise[]
  user      User?      @relation(fields: [userId], references: [id])
  userId    String?
}

model User {
  id        String   @id @default(uuid())
  routines  Routine[]
}

model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  exercises Exercise[]
  user      User?      @relation(fields: [userId], references: [id])
  userId    String?
}

Now, a Routine can exist without being related to a User. However, please note that this might not be the best practice depending on your application's requirements. If a Routine should logically always belong to a User, it might be better to keep the relation mandatory and ensure a User is always provided when creating a Routine. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

Thx ma boi! @kapa.ai Solved thx! Next question: I'm working with OpenSaaS SaaS template. I'm modifiying the @src/client/components/AppNavBar.tsx I modified the:

const navigation = [
  { name: 'Body Parts', href: routes.BodyPartsPageRoute.build() },
  { name: 'Exercises', href: routes.ExercisesPageRoute.build() },
  { name: 'Rotines', href: routes.RoutinesPageRoute.build() },
  { name: 'Pricing', href: routes.PricingPageRoute.build() },
  { name: 'Documentation', href: DocsUrl },
  // { name: 'Blog', href: BlogUrl },
];

To add from main.wasp:

route BodyPartsRoute { path: "/bodyparts", to: BodyPartsPage }
page BodyPartsPage {
  authRequired: true,
  component: import BodyPartsPage from "@src/dashboard/bodyparts/BodyPartsPage"
}

// Exercise Route
route ExercisesRoute { path: "/exercises", to: ExercisesPage }
page ExercisesPage {
  authRequired: true,
  component: import ExercisesPage from "@src/dashboard/exercises/ExercisesPage"
}

// Routine Route
route RoutinesRoute { path: "/routines", to: RoutinesPage }
page RoutinesPage {
  component: import RoutinesPage from "@src/dashboard/routines/RoutinesPage",
  authRequired: true
}

And It gives me these errors:

[  Wasp  ] ext-src/client/components/AppNavBar.tsx(15,38): error TS2551: Property 'BodyPartsPageRoute' does not exist on type '{ readonly LoginRoute: { readonly to: "/login"; readonly build: (options?: OptionalRouteOptions) => string; }; readonly SignupRoute: { readonly to: "/signup"; readonly build: (options?: OptionalRouteOptions) => string; }; ... 21 more ...; readonly RoutinesRoute: { ...; }; }'. Did you mean 'BodyPartsRoute'?
[  Wasp  ] ext-src/client/components/AppNavBar.tsx(16,37): error TS2551: Property 'ExercisesPageRoute' does not exist on type '{ readonly LoginRoute: { readonly to: "/login"; readonly build: (options?: OptionalRouteOptions) => string; }; readonld: (options?: OptionalRouteOptions) => string; }; readonly SignupRoute: { readonly to: "/signup"; readonly build: (options?: OptionalRouteOptions) => string; }; ... 21 more ...; readonly R?outinesRoute: { ...; }; }'. Did you mean 'ExercisesRoute'?                                                                                                                                  : (options?: OptionalRouteOptions) => string; }; readonly
[  Wasp  ] ext-src/client/components/AppNavBar.tsx(17,35): error TS2551: Property 'RoutinesPageRoute' does not exist on type '{ readonly LoginRoute: { readonly to: "/login"; readonly build: (options?: OptionalRouteOptions) => string; }; readonly SignupRoute: { readonly to: "/signup"; readonly build: (options?: OptionalRouteOptions) => string; }; ... 21 more ...; readonly RoutinesRoute: { ...; }; }'. Did you mean 'RoutinesRoute'?

What I'm doing wrong?

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- The error messages indicate that the properties BodyPartsPageRoute, ExercisesPageRoute, and RoutinesPageRoute do not exist on the routes object. Instead, the properties BodyPartsRoute, ExercisesRoute, and RoutinesRoute exist. This suggests that the names of the routes in the routes object do not match the names you're using in the navigation array. You should modify the navigation array to use the correct route names:

const navigation = [
  { name: 'Body Parts', href: routes.BodyPartsRoute.build() },
  { name: 'Exercises', href: routes.ExercisesRoute.build() },
  { name: 'Rotines', href: routes.RoutinesRoute.build() },
  { name: 'Pricing', href: routes.PricingPageRoute.build() },
  { name: 'Documentation', href: DocsUrl },
  // { name: 'Blog', href: BlogUrl },
];

const navigation = [
  { name: 'Body Parts', href: routes.BodyPartsRoute.build() },
  { name: 'Exercises', href: routes.ExercisesRoute.build() },
  { name: 'Rotines', href: routes.RoutinesRoute.build() },
  { name: 'Pricing', href: routes.PricingPageRoute.build() },
  { name: 'Documentation', href: DocsUrl },
  // { name: 'Blog', href: BlogUrl },
];

This should resolve the TypeScript errors you're seeing. If you're still having trouble, consider asking for help on the Wasp Discord server (https://discord.com/channels/686873244791210014/1212533517360177253) or opening an issue on the Wasp GitHub repository (https://github.com/wasp-lang/wasp/issues). ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

fixed ma boi @kapa.ai fixed, thx! Based on this schema.prisma:

model User {
  id        String   @id @default(uuid())
  routines  Routine[] 
}

model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  exercises Exercise[] 
  user      User       @relation(fields: [userId], references: [id])
  userId    String
}

model Exercise {
  id                Int       @id @default(autoincrement())
  name              String
  instructions      String
  difficulty        Difficulty
  equipmentRequired Boolean
  equipment         String?
  bodyPart          BodyPart  @relation(fields: [bodyPartId], references: [id])
  bodyPartId        Int
  routines          Routine[]
}

model BodyPart {
  id        Int        @id @default(autoincrement())
  name      String     @unique  
    description String?    
  exercises Exercise[]
}

Would I need to make any changes to, for example, create a routine, assign 2 exercises to it and specify sets, reps, weights and rest for each exercise in the routine?

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- Based on your current schema.prisma, you don't have a way to specify sets, reps, weights, and rest for each exercise in a routine. To achieve this, you would need to introduce a new model that represents an instance of an exercise in a routine, with its own sets, reps, weights, and rest. Here's an example of how you could modify your schema:

model User {
  id        String   @id @default(uuid())
  routines  Routine[] 
}

model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  routineExercises RoutineExercise[] 
  user      User       @relation(fields: [userId], references: [id])
  userId    String
}

model Exercise {
  id                Int       @id @default(autoincrement())
  name              String
  instructions      String
  difficulty        Difficulty
  equipmentRequired Boolean
  equipment         String?
  bodyPart          BodyPart  @relation(fields: [bodyPartId], references: [id])
  bodyPartId        Int
  routineExercises  RoutineExercise[]
}

model BodyPart {
  id        Int        @id @default(autoincrement())
  name      String     @unique  
  description String?    
  exercises Exercise[]
}

model RoutineExercise {
  id        Int        @id @default(autoincrement())
  sets      Int
  reps      Int
  weight    Float
  rest      Int
  routine   Routine    @relation(fields: [routineId], references: [id])
  routineId Int
  exercise  Exercise   @relation(fields: [exerciseId], references: [id])
  exerciseId Int
}

model User {
  id        String   @id @default(uuid())
  routines  Routine[] 
}

model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  routineExercises RoutineExercise[] 
  user      User       @relation(fields: [userId], references: [id])
  userId    String
}

model Exercise {
  id                Int       @id @default(autoincrement())
  name              String
  instructions      String
  difficulty        Difficulty
  equipmentRequired Boolean
  equipment         String?
  bodyPart          BodyPart  @relation(fields: [bodyPartId], references: [id])
  bodyPartId        Int
  routineExercises  RoutineExercise[]
}

model BodyPart {
  id        Int        @id @default(autoincrement())
  name      String     @unique  
  description String?    
  exercises Exercise[]
}

model RoutineExercise {
  id        Int        @id @default(autoincrement())
  sets      Int
  reps      Int
  weight    Float
  rest      Int
  routine   Routine    @relation(fields: [routineId], references: [id])
  routineId Int
  exercise  Exercise   @relation(fields: [exerciseId], references: [id])
  exerciseId Int
}

In this modified schema, a Routine has many RoutineExercises, and each RoutineExercise is associated with one Exercise and one Routine. The RoutineExercise model has fields for sets, reps, weight, and rest. Now, to create a routine, assign 2 exercises to it, and specify sets, reps, weights, and rest for each exercise, you would create a Routine, two Exercises (if they don't exist already), and two RoutineExercises that link the Routine and Exercises together and specify the sets, reps, weights, and rest. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai Thanks! I just implemented the RoutineExercise model and its relationships, wasp db migrate-dev worked fine. Now I have a form component to add routines. It has a name field and a field to select the exercises and a submit button. In this case I want to create the necessary actions and queries to modify this form and add these new functions to be able to assign within a routine different sets of repetitions, weight, rest for each exercise.

// src/dashboard/routines/RoutineForm.tsx
import React, { useState } from 'react';
import { Exercise } from 'wasp/entities';
import { createRoutine } from 'wasp/client/operations';
import { Card, CardBody, Input, Button, Select, SelectItem } from '@nextui-org/react';

// Definimos el tipo para la entrada de createRoutine
type CreateRoutineInput = {
  name: string;
  exerciseIds: number[];
};

interface RoutineFormProps {
  onRoutineCreated: () => void;
  exercises: Exercise[];
}

export function RoutineForm({ onRoutineCreated, exercises }: RoutineFormProps) {
  const [newRoutine, setNewRoutine] = useState<CreateRoutineInput>({
    name: '',
    exerciseIds: []
  });

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    try {
      if (newRoutine.name && newRoutine.exerciseIds.length > 0) {
        await createRoutine(newRoutine);
        setNewRoutine({ name: '', exerciseIds: [] });
        onRoutineCreated();
      } else {
        console.error('Missing required fields');
      }
    } catch (err) {
      console.error('Error creating routine:', err);
    }
  };

  return (
    <Card className="rounded-lg shadow-md dark:border-strokedark dark:bg-boxdark max-w-lg mx-auto">
      <CardBody className="rounded-lg p-6">
        <h3 className="text-2xl font-bold mb-6 text-black dark:text-white">Add Routine</h3>
        <form onSubmit={handleSubmit} className="space-y-6">
          <div className="mb-6">
            <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Name</label>
            <Input
              value={newRoutine.name}
              onChange={(e) => setNewRoutine({ ...newRoutine, name: e.target.value })}
              placeholder="Enter routine name"
              className="w-full mt-1 dark:bg-gray-800 dark:text-white"
            />
          </div>
          
          <div className="mb-6">
  <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Exercises</label>
  <Select
    selectionMode="multiple"
    placeholder="Select exercises"
    selectedKeys={new Set(newRoutine.exerciseIds.map(String))}
    onSelectionChange={(keys) => setNewRoutine({ ...newRoutine, exerciseIds: Array.from(keys as Set<string>, Number) })}
    className="w-full mt-1 dark:bg-gray-800 dark:text-white"
  >
    {exercises.map((exercise) => (
      <SelectItem key={exercise.id.toString()} value={exercise.id.toString()} className="bg-white dark:bg-gray-800 text-black dark:text-white">
        {exercise.name}
      </SelectItem>
    ))}
  </Select>
</div>


          <Button 
            type="submit" 
            className="w-full bg-primary-500 text-white hover:bg-primary-700 rounded-lg py-2"
          >
            Add Routine
          </Button>
        </form>
      </CardBody>
    </Card>
  );
}

First at all, what kind of actions/queries Should they be for all this to work properly? Remember that after creating a routine we have the possibility to delete and update it (apart from being able to list them all).

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai Thanks! I just implemented the RoutineExercise model and its relationships, wasp db migrate-dev worked fine. Now I have a form component to add routines. It has a name field and a field to select the exercises and a submit button. In this case I want to create the necessary actions and queries to modify this form and add these new functions to be able to assign within a routine different sets of repetitions, weight, rest for each exercise. // src/dashboard/routines/RoutineForm.tsx import React, { useState } from 'react'; import { Exercise } from 'wasp/entities'; import { createRoutine } from 'wasp/client/operations'; import { Card, CardBody, Input, Button, Select, SelectItem } from '@nextui-org/react'; type CreateRoutineInput = { name: string; exerciseIds: number[]; }; interface RoutineFormProps { onRoutineCreated: () => void; exercises: Exercise[]; } export function RoutineForm({ onRoutineCreated, exercises }: RoutineFormProps) { const [newRoutine, setNewRoutine] = useState<CreateRoutineInput>({ name: '', exerciseIds: [] }); const handleSubmit = async (e: React.FormEvent) => { e.preventDefault(); try { if (newRoutine.name && newRoutine.exerciseIds.length > 0) { await createRoutine(newRoutine); setNewRoutine({ name: '', exerciseIds: [] }); onRoutineCreated(); } else { console.error('Missing required fields'); } } catch (err) { console.error('Error creating routine:', err); } }; return ( <Card className="rounded-lg shadow-md dark:border-strokedark dark:bg-boxdark max-w-lg mx-auto"> <CardBody className="rounded-lg p-6"> <h3 className="text-2xl font-bold mb-6 text-black dark:text-white">Add Routine</h3> <form onSubmit={handleSubmit} className="space-y-6"> <div className="mb-6"> <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Name</label> <Input value={newRoutine.name} onChange={(e) => setNewRoutine({ ...newRoutine, name: e.target.value })} placeholder="Enter routine name" className="w-full mt-1 dark:bg-gray-800 dark:text-white" /> </div>
<div className="mb-6"> <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Exercises</label> <Select selectionMode="multiple" placeholder="Select exercises" selectedKeys={new Set(newRoutine.exerciseIds.map(String))} onSelectionChange={(keys) => setNewRoutine({ ...newRoutine, exerciseIds: Array.from(keys as Set<string>, Number) })} className="w-full mt-1 dark:bg-gray-800 dark:text-white" > {exercises.map((exercise) => ( <SelectItem key={exercise.id.toString()} value={exercise.id.toString()} className="bg-white dark:bg-gray-800 text-black dark:text-white"> {exercise.name} </SelectItem> ))} </Select> </div> <Button type="submit" className="w-full bg-primary-500 text-white hover:bg-primary-700 rounded-lg py-2" > Add Routine </Button> </form> </CardBody> </Card> ); } First at all, what kind of actions/queries Should they be for all this to work properly? Remember that after creating a routine we have the possibility to delete and update it (apart from being able to list them all).

kapa.ai•2mo ago

NEROXOP•2mo ago

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- To implement the functionality you described, you would need the following actions and queries: 1. CreateRoutineAction: This action would create a new Routine and associated RoutineExercises. It would take as arguments the name of the routine, and an array of objects representing the exercises to be included in the routine, with each object containing the exercise ID and the sets, reps, weight, and rest for that exercise. 2. GetRoutinesQuery: This query would fetch all routines along with their associated exercises and the sets, reps, weight, and rest for each exercise. 3. GetRoutineQuery: This query would fetch a single routine by its ID, along with its associated exercises and the sets, reps, weight, and rest for each exercise. 4. UpdateRoutineAction: This action would update a routine and its associated RoutineExercises. It would take as arguments the ID of the routine to be updated, the new name of the routine (if it is to be changed), and an array of objects representing the new set of exercises to be included in the routine, with each object containing the exercise ID and the sets, reps, weight, and rest for that exercise. 5. DeleteRoutineAction: This action would delete a routine and its associated RoutineExercises. It would take as arguments the ID of the routine to be deleted. Please note that implementing these actions and queries would involve writing JavaScript/TypeScript code to interact with the Prisma Client API, which is beyond the scope of this response. For more information on how to implement actions and queries in Wasp, you can refer to the Wasp documentation (https://wasp-lang.dev/docs/tutorial/actions). ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai Could you provide me with the 5 example actions or queries in code based on the updated schema.prisma please?

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- Sure, here are examples of how you could define these actions and queries in Wasp: 1. CreateRoutineAction:

export const createRoutine = async (args, context) => {
  const { name, exercises } = args
  const routine = await context.entities.Routine.create({
    data: {
      name,
      routineExercises: {
        create: exercises.map(exercise => ({
          sets: exercise.sets,
          reps: exercise.reps,
          weight: exercise.weight,
          rest: exercise.rest,
          exerciseId: exercise.id
        }))
      }
    }
  })
  return routine
}

export const createRoutine = async (args, context) => {
  const { name, exercises } = args
  const routine = await context.entities.Routine.create({
    data: {
      name,
      routineExercises: {
        create: exercises.map(exercise => ({
          sets: exercise.sets,
          reps: exercise.reps,
          weight: exercise.weight,
          rest: exercise.rest,
          exerciseId: exercise.id
        }))
      }
    }
  })
  return routine
}

2. GetRoutinesQuery:

export const getRoutines = async (args, context) => {
  return context.entities.Routine.findMany({
    include: {
      routineExercises: {
        include: {
          exercise: true
        }
      }
    }
  })
}

export const getRoutines = async (args, context) => {
  return context.entities.Routine.findMany({
    include: {
      routineExercises: {
        include: {
          exercise: true
        }
      }
    }
  })
}

3. GetRoutineQuery:

export const getRoutine = async (args, context) => {
  return context.entities.Routine.findUnique({
    where: { id: args.id },
    include: {
      routineExercises: {
        include: {
          exercise: true
        }
      }
    }
  })
}

export const getRoutine = async (args, context) => {
  return context.entities.Routine.findUnique({
    where: { id: args.id },
    include: {
      routineExercises: {
        include: {
          exercise: true
        }
      }
    }
  })
}

4. UpdateRoutineAction:

export const updateRoutine = async (args, context) => {
  const { id, name, exercises } = args
  const routine = await context.entities.Routine.update({
    where: { id },
    data: {
      name,
      routineExercises: {
        deleteMany: {},
        create: exercises.map(exercise => ({
          sets: exercise.sets,
          reps: exercise.reps,
          weight: exercise.weight,
          rest: exercise.rest,
          exerciseId: exercise.id
        }))
      }
    }
  })
  return routine
}

export const updateRoutine = async (args, context) => {
  const { id, name, exercises } = args
  const routine = await context.entities.Routine.update({
    where: { id },
    data: {
      name,
      routineExercises: {
        deleteMany: {},
        create: exercises.map(exercise => ({
          sets: exercise.sets,
          reps: exercise.reps,
          weight: exercise.weight,
          rest: exercise.rest,
          exerciseId: exercise.id
        }))
      }
    }
  })
  return routine
}

5. DeleteRoutineAction:

export const deleteRoutine = async (args, context) => {
  return context.entities.Routine.delete({
    where: { id: args.id }
  })
}

export const deleteRoutine = async (args, context) => {
  return context.entities.Routine.delete({
    where: { id: args.id }
  })
}

Please note that these are just examples and might need to be adjusted based on your exact requirements and the structure of your application. Also, these examples assume that you have defined Routine, Exercise, and RoutineExercise entities in your main.wasp file and that these entities correspond to the Routine, Exercise, and RoutineExercise models in your Prisma schema. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai for CreateRoutine, deleteRoutine and updateRoutine, actually I have this:

export const createRoutine: CreateRoutine<CreateRoutineInput, Routine> = async (args, context) => {
  const { name, exerciseIds } = args;

type CreateRoutineInput = Pick<Routine, 'name'> & { exerciseIds: number[] };

export const createRoutine: CreateRoutine<CreateRoutineInput, Routine> = async (args, context) => {
  const { name, exerciseIds } = args;

  return context.entities.Routine.create({
    data: {
      name,
      exercises: {
        connect: exerciseIds.map(id => ({ id }))
      },
      user: {
        connect: { id: context.user.id }
      }
    },
    include: { exercises: true }
  });
};

type UpdateRoutineInput = Partial<Routine> & { id: number, exerciseIds?: number[] };

export const updateRoutine: UpdateRoutine<UpdateRoutineInput, Routine> = async (args, context) => {
  const { id, exerciseIds, ...updateData } = args;

  return context.entities.Routine.update({
    where: { id },
    data: {
      ...updateData,
      ...(exerciseIds && {
        exercises: {
          set: exerciseIds.map(id => ({ id }))
        }
      })
    },
    include: { exercises: true }
  });
};

export const deleteRoutine: DeleteRoutine<{ id: number }, void> = async (args, context) => {
  await context.entities.Routine.delete({
    where: { id: args.id }
  });
};

How you will update them with your new updates?

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- Sure, here's how you could update your existing actions to include the new functionality: 1. CreateRoutineAction:

type CreateRoutineInput = Pick<Routine, 'name'> & { exercises: { id: number, sets: number, reps: number, weight: number, rest: number }[] };

export const createRoutine: CreateRoutine<CreateRoutineInput, Routine> = async (args, context) => {
  const { name, exercises } = args;

  return context.entities.Routine.create({
    data: {
      name,
      routineExercises: {
        create: exercises.map(exercise => ({
          sets: exercise.sets,
          reps: exercise.reps,
          weight: exercise.weight,
          rest: exercise.rest,
          exerciseId: exercise.id
        }))
      },
      user: {
        connect: { id: context.user.id }
      }
    },
    include: { routineExercises: { include: { exercise: true } } }
  });
};

type CreateRoutineInput = Pick<Routine, 'name'> & { exercises: { id: number, sets: number, reps: number, weight: number, rest: number }[] };

export const createRoutine: CreateRoutine<CreateRoutineInput, Routine> = async (args, context) => {
  const { name, exercises } = args;

  return context.entities.Routine.create({
    data: {
      name,
      routineExercises: {
        create: exercises.map(exercise => ({
          sets: exercise.sets,
          reps: exercise.reps,
          weight: exercise.weight,
          rest: exercise.rest,
          exerciseId: exercise.id
        }))
      },
      user: {
        connect: { id: context.user.id }
      }
    },
    include: { routineExercises: { include: { exercise: true } } }
  });
};

2. UpdateRoutineAction:

type UpdateRoutineInput = Partial<Routine> & { id: number, exercises?: { id: number, sets: number, reps: number, weight: number, rest: number }[] };

export const updateRoutine: UpdateRoutine<UpdateRoutineInput, Routine> = async (args, context) => {
  const { id, exercises, ...updateData } = args;

  return context.entities.Routine.update({
    where: { id },
    data: {
      ...updateData,
      ...(exercises && {
        routineExercises: {
          deleteMany: {},
          create: exercises.map(exercise => ({
            sets: exercise.sets,
            reps: exercise.reps,
            weight: exercise.weight,
            rest: exercise.rest,
            exerciseId: exercise.id
          }))
        }
      })
    },
    include: { routineExercises: { include: { exercise: true } } }
  });
};

type UpdateRoutineInput = Partial<Routine> & { id: number, exercises?: { id: number, sets: number, reps: number, weight: number, rest: number }[] };

export const updateRoutine: UpdateRoutine<UpdateRoutineInput, Routine> = async (args, context) => {
  const { id, exercises, ...updateData } = args;

  return context.entities.Routine.update({
    where: { id },
    data: {
      ...updateData,
      ...(exercises && {
        routineExercises: {
          deleteMany: {},
          create: exercises.map(exercise => ({
            sets: exercise.sets,
            reps: exercise.reps,
            weight: exercise.weight,
            rest: exercise.rest,
            exerciseId: exercise.id
          }))
        }
      })
    },
    include: { routineExercises: { include: { exercise: true } } }
  });
};

3. DeleteRoutineAction: Your deleteRoutine action should work as is, because deleting a Routine will also delete its associated RoutineExercises due to the cascading delete behavior in Prisma. Please note that these are just examples and might need to be adjusted based on your exact requirements and the structure of your application. Also, these examples assume that you have defined Routine, Exercise, and RoutineExercise entities in your main.wasp file and that these entities correspond to the Routine, Exercise, and RoutineExercise models in your Prisma schema. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai Thanks! do I need to import the RoutineExercise? I'm just importing this right now: import { Routine } from 'wasp/entities';

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- Yes, you would need to import RoutineExercise from wasp/entities if you want to use it in your TypeScript code for type checking. You can import it like this:

import { Routine, RoutineExercise } from 'wasp/entities'

import { Routine, RoutineExercise } from 'wasp/entities'

This will allow you to use RoutineExercise in your TypeScript code for type checking and autocompletion. However, please note that this assumes that you have defined a RoutineExercise entity in your main.wasp file that corresponds to the RoutineExercise model in your Prisma schema. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai Previously in my execise queries I had:

import { GetRoutines } from 'wasp/server/operations';
import { Routine } from 'wasp/entities';

export const getRoutines: GetRoutines<void, Routine[]> = async (args, context) => {
  return context.entities.Routine.findMany({
    include: { exercises: true }
  });
};

Now I have:

import { GetRoutines } from 'wasp/server/operations';
import { Routine } from 'wasp/entities';

export const getRoutines: GetRoutines<void, Routine[]> = async (args, context) => {
  return context.entities.Routine.findMany({
    include: { exercises: true }
  });
};

export const getRoutine = async (args, context) => {
  return context.entities.Routine.findUnique({
    where: { id: args.id },
    include: {
      routineExercises: {
        include: {
          exercise: true
        }
      }
    }
  })
}

All my actions and queries regarding exercises are these in my main.wasp:

// Routine Queries
query getRoutines {
  fn: import { getRoutines } from "@src/dashboard/routines/RoutineQueries",
  entities: [Routine, Exercise]
}

// Routine Actions
action createRoutine {
  fn: import { createRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise]
}

action updateRoutine {
  fn: import { updateRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise]
}

action deleteRoutine {
  fn: import { deleteRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine]
}

Do you think there is a missing query in main.wasp related to the exercises?

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- Based on your updated getRoutines and getRoutine queries, it seems like you are now including routineExercises (which includes exercise) when fetching routines. This means you are fetching not just the routines, but also the exercises associated with each routine, along with the sets, reps, weight, and rest for each exercise. However, in your main.wasp file, you are only specifying Routine and Exercise entities for your getRoutines query. You should also include RoutineExercise in the entities array, since your getRoutines and getRoutine queries are now also dealing with RoutineExercise. Here's how you could update your main.wasp file:

// Routine Queries
query getRoutines {
  fn: import { getRoutines } from "@src/dashboard/routines/RoutineQueries",
  entities: [Routine, Exercise, RoutineExercise]
}

query getRoutine {
  fn: import { getRoutine } from "@src/dashboard/routines/RoutineQueries",
  entities: [Routine, Exercise, RoutineExercise]
}

// Routine Actions
action createRoutine {
  fn: import { createRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise, RoutineExercise]
}

action updateRoutine {
  fn: import { updateRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise, RoutineExercise]
}

action deleteRoutine {
  fn: import { deleteRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, RoutineExercise]
}

// Routine Queries
query getRoutines {
  fn: import { getRoutines } from "@src/dashboard/routines/RoutineQueries",
  entities: [Routine, Exercise, RoutineExercise]
}

query getRoutine {
  fn: import { getRoutine } from "@src/dashboard/routines/RoutineQueries",
  entities: [Routine, Exercise, RoutineExercise]
}

// Routine Actions
action createRoutine {
  fn: import { createRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise, RoutineExercise]
}

action updateRoutine {
  fn: import { updateRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, Exercise, RoutineExercise]
}

action deleteRoutine {
  fn: import { deleteRoutine } from "@src/dashboard/routines/RoutineActions",
  entities: [Routine, RoutineExercise]
}

Please note that this assumes that you have defined a RoutineExercise entity in your main.wasp file that corresponds to the RoutineExercise model in your Prisma schema. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

Solved again good boi, take this monie 🪙

MEE6•2mo ago

Wohooo @NEROX, you just became a Waspeteer level 7!

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- Based on the provided Prisma schema, you have several models defined: User, WeightLog, Routine, RoutineExercise, Exercise, and BodyPart. Here's a brief overview of each model: 1. User: Represents a user in your application. Each user has a unique id and can have multiple routines. 2. WeightLog: Represents a weight log entry for a user. Each entry has a unique id, a createdAt timestamp, a user relation to the User model, a userId field, a weight field representing the user's weight in kilograms, and a date field representing the date and time of the weight log entry. 3. Routine: Represents a routine in your application. Each routine has a unique id, a name, multiple exercises through a many-to-many relation with the Exercise model, a user relation to the User model, a userId field, and multiple routineExercises. 4. RoutineExercise: Represents an exercise within a routine. Each routine exercise has a unique id, sets, reps, weight, rest, a routine relation to the Routine model, a routineId field, an exercise relation to the Exercise model, and an exerciseId field. 5. Exercise: Represents an exercise in your application. Each exercise has a unique id, a name, a bodyPart relation to the BodyPart model, a bodyPartId field, multiple routines through a many-to-many relation with the Routine model, and multiple routineExercises. 6. BodyPart: Represents a body part in your application. Each body part has a unique id, a unique name, and multiple exercises. This schema allows you to model complex relationships between users, their routines, the exercises within those routines, and the body parts targeted by those exercises. It also allows you to track each user's weight over time. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai

model User {
  id        String   @id @default(uuid())
  routines  Routine[]
}

model Routine {
  id        Int        @id @default(autoincrement())
  name      String
  exercises Exercise[]
  user      User       @relation(fields: [userId], references: [id])
  userId    String
    routineExercises RoutineExercise[] 

}

model RoutineExercise {
  id        Int        @id @default(autoincrement())
  sets      Int
  reps      Int
  weight    Float
  rest      Int
  routine   Routine    @relation(fields: [routineId], references: [id])
  routineId Int
  exercise  Exercise   @relation(fields: [exerciseId], references: [id])
  exerciseId Int

}

model Exercise {
  id                Int       @id @default(autoincrement())
  name              String
  bodyPart          BodyPart  @relation(fields: [bodyPartId], references: [id])
  bodyPartId        Int
  routines          Routine[]
    routineExercises  RoutineExercise[]

}

model BodyPart {
  id        Int        @id @default(autoincrement())
  name      String     @unique 
  exercises Exercise[]
}

Based on this model of schema.prisma, How would you create the function to update a routine? I mean, inside it I can change the kg, reps, rest, add or remove an exercise, etc...

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- To update a routine along with its associated exercises, sets, reps, weight, and rest, you would need to create an action that updates both the Routine and RoutineExercise models. Here's an example of how you could define this action:

type UpdateRoutineInput = {
  id: number,
  name?: string,
  routineExercises?: {
    id: number,
    sets?: number,
    reps?: number,
    weight?: number,
    rest?: number,
    exerciseId?: number
  }[]
};

export const updateRoutine: UpdateRoutine<UpdateRoutineInput, Routine> = async (args, context) => {
  const { id, name, routineExercises } = args;

  // First, update the routine itself.
  await context.entities.Routine.update({
    where: { id },
    data: { name }
  });

  // Then, update each associated routine exercise.
  if (routineExercises) {
    for (const routineExercise of routineExercises) {
      await context.entities.RoutineExercise.update({
        where: { id: routineExercise.id },
        data: {
          sets: routineExercise.sets,
          reps: routineExercise.reps,
          weight: routineExercise.weight,
          rest: routineExercise.rest,
          exerciseId: routineExercise.exerciseId
        }
      });
    }
  }

  // Finally, return the updated routine.
  return context.entities.Routine.findUnique({
    where: { id },
    include: {
      routineExercises: {
        include: {
          exercise: true
        }
      }
    }
  });
};

type UpdateRoutineInput = {
  id: number,
  name?: string,
  routineExercises?: {
    id: number,
    sets?: number,
    reps?: number,
    weight?: number,
    rest?: number,
    exerciseId?: number
  }[]
};

export const updateRoutine: UpdateRoutine<UpdateRoutineInput, Routine> = async (args, context) => {
  const { id, name, routineExercises } = args;

  // First, update the routine itself.
  await context.entities.Routine.update({
    where: { id },
    data: { name }
  });

  // Then, update each associated routine exercise.
  if (routineExercises) {
    for (const routineExercise of routineExercises) {
      await context.entities.RoutineExercise.update({
        where: { id: routineExercise.id },
        data: {
          sets: routineExercise.sets,
          reps: routineExercise.reps,
          weight: routineExercise.weight,
          rest: routineExercise.rest,
          exerciseId: routineExercise.exerciseId
        }
      });
    }
  }

  // Finally, return the updated routine.
  return context.entities.Routine.findUnique({
    where: { id },
    include: {
      routineExercises: {
        include: {
          exercise: true
        }
      }
    }
  });
};

This updateRoutine action first updates the Routine itself, then updates each associated RoutineExercise. It then returns the updated Routine along with its associated RoutineExercises and Exercises. Please note that this is just an example and might need to be adjusted based on your exact requirements and the structure of your application. Also, this example assumes that you have defined Routine and RoutineExercise entities in your main.wasp file and that these entities correspond to the Routine and RoutineExercise models in your Prisma schema. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai Thanks! And the action to delete a routine? Note that the data of kg, reps, rest, series, etc. would also be eliminated.

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- To delete a routine along with its associated RoutineExercises, you can use the delete method provided by Prisma. Here's an example of how you could define this action:

type DeleteRoutineInput = {{ id: number }};

export const deleteRoutine: DeleteRoutine<DeleteRoutineInput, void> = async (args, context) => {{
  await context.entities.Routine.delete({{
    where: {{ id: args.id }}
  }});
}};

type DeleteRoutineInput = {{ id: number }};

export const deleteRoutine: DeleteRoutine<DeleteRoutineInput, void> = async (args, context) => {{
  await context.entities.Routine.delete({{
    where: {{ id: args.id }}
  }});
}};

This deleteRoutine action deletes the Routine with the specified id. Due to the cascading delete behavior in Prisma, all associated RoutineExercises will also be deleted. Please note that this is just an example and might need to be adjusted based on your exact requirements and the structure of your application. Also, this example assumes that you have defined a Routine entity in your main.wasp file and that this entity corresponds to the Routine model in your Prisma schema. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai I did the changes but:

[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(81,28): error TS1131: Property or signature expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(81,42): error TS1128: Declaration or statement expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(84,42): error TS1136: Property assignment expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(85,13): error TS1136: Property assignment expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(85,28): error TS1005: ',' expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(86,4): error TS1128: Declaration or statement expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(86,5): error TS1128: Declaration or statement expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(87,1): error TS1128: Declaration or statement expected.
[  Wasp  ] ext-src/dashboard/routines/RoutineActions.ts(87,2): error TS1128: Declaration or statement expected.

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- The error messages you're seeing are TypeScript compilation errors. They suggest that there might be some syntax errors in your RoutineActions.ts file. Unfortunately, without seeing the actual code in RoutineActions.ts, it's hard to pinpoint the exact issue. However, here are some general tips: - Make sure all your objects, arrays, and function calls have matching opening and closing brackets or parentheses. - Ensure that all properties in your objects are correctly assigned using : and not =. - Check that all statements are correctly terminated with a semicolon (;). If you're still having trouble, I would recommend carefully reviewing your RoutineActions.ts file, particularly around the lines mentioned in the error messages. If you're using an IDE like Visual Studio Code, it should highlight any syntax errors for you. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

@kapa.ai those are the lines:

type DeleteRoutineInput = {{ id: number }};

export const deleteRoutine: DeleteRoutine<DeleteRoutineInput, void> = async (args, context) => {{
  await context.entities.Routine.delete({{
    where: {{ id: args.id }}
  }});
}};

kapa.ai•2mo ago

Let me check the knowledge base for you. One moment! :books: ---------------------- The code you've provided seems to be correct. It defines a TypeScript type for the input to the deleteRoutine function and then defines the deleteRoutine function itself. This function is an asynchronous function that deletes a Routine entity based on the provided id. If you're seeing TypeScript errors with this code, it could be due to issues elsewhere in your RoutineActions.ts file or due to a mismatch between the types you're using and the types defined in your Wasp and Prisma schemas. Here are a few things you could check: 1. Make sure the DeleteRoutine type is correctly imported at the top of your RoutineActions.ts file. You should have a line like this:

import { DeleteRoutine } from 'wasp/actions';

import { DeleteRoutine } from 'wasp/actions';

2. Ensure that the Routine entity is correctly defined in your main.wasp file and that it corresponds to the Routine model in your Prisma schema. 3. Check the rest of your RoutineActions.ts file for any syntax errors or type mismatches that could be causing the TypeScript compiler to throw errors. If you're still having trouble, please provide the full content of your RoutineActions.ts file and the exact error message you're seeing, and I'll be happy to help you troubleshoot further. ---------------------- Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: ---------------------- Sorry @NEROX, 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?

NEROXOP•2mo ago

Fixed! Done for today ma' boi, here another monie for you🪙

Gaming

Programming

SDK build failed with exit code: 2