Fix directly calling operations on the frontend

waspc/data/Generator/templates/sdk/wasp/client/operations/actions/core.ts

@@ -41,8 +41,9 @@ export function createAction<BackendAction extends GenericBackendAction>(
 }
 
 // PRIVATE API
-export type ActionFor<BackendAction extends GenericBackendAction> =
-  Action<Parameters<BackendAction>[0], _Awaited<_ReturnType<BackendAction>>>
-
+export type ActionFor<BackendQuery extends GenericBackendAction> =
+  Parameters<BackendQuery> extends []
+    ? Action<void, _Awaited<_ReturnType<BackendQuery>>>
+    : Action<Parameters<BackendQuery>[0], _Awaited<_ReturnType<BackendQuery>>>
 
 type GenericBackendAction = (args: never, context: any) => unknown

waspc/data/Generator/templates/sdk/wasp/client/operations/core.ts

@@ -7,44 +7,50 @@ import {
   useQuery as rqUseQuery,
   UseQueryResult,
 } from "@tanstack/react-query";
+import { Route } from "wasp/client";
 export { configureQueryClient } from "./queryClient";
 
-// PRIVATE API (but should maybe be public, users use values of this type)
-export type Query<Input, Output> = {
-  (queryCacheKey: string[], args: Input): Promise<Output>;
-};
+// PRIVATE API (but should maybe be public, users define values of this type)
+export type Query<Input, Output> = Operation<Input, Output>
 
 // PUBLIC API
 export function useQuery<Input, Output>(
   queryFn: Query<Input, Output>,
   queryFnArgs?: Input,
   options?: any
-): UseQueryResult<Output, Error>;
-
-// PUBLIC API
-export function useQuery(queryFn, queryFnArgs, options) {
-  if (typeof queryFn !== "function") {
-    throw new TypeError("useQuery requires queryFn to be a function.");
+): UseQueryResult<Output, Error> {
+  if (typeof queryFn !== 'function') {
+    throw new TypeError('useQuery requires queryFn to be a function.')
   }
-  if (!queryFn.queryCacheKey) {
-    throw new TypeError(
-      "queryFn needs to have queryCacheKey property defined."
-    );
+  const internalQueryFn = queryFn as InternalViewOf<typeof queryFn>
+
+  if (!internalQueryFn.queryCacheKey) {
+    throw new TypeError('queryFn needs to have queryCacheKey property defined.')
   }
 
   const queryKey =
     queryFnArgs !== undefined
-      ? [...queryFn.queryCacheKey, queryFnArgs]
-      : queryFn.queryCacheKey;
+      ? [...internalQueryFn.queryCacheKey, queryFnArgs]
+      : internalQueryFn.queryCacheKey
   return rqUseQuery({
     queryKey,
-    queryFn: () => queryFn(queryKey, queryFnArgs),
+    queryFn: () => internalQueryFn(queryFnArgs),
     ...options,
-  });
+  })
+}
+
+// PRIVATE API (needed in SDK)
+export type InternalViewOf<Q extends Query<never, unknown>> = Q & {
+  route: Route,
+  queryCacheKey: string[],
 }
 
+// PRIVATE API (but should maybe be public, users define values of this type)
+export type Action<Input, Output> = Operation<Input, Output>
+
 // PRIVATE API (but should maybe be public, users use values of this type)
-export type Action<Input, Output> = [Input] extends [never]
+// Read this to understand the type: https://github.com/wasp-lang/wasp/pull/1090#discussion_r1159732471
+export type Operation<Input, Output> = [Input] extends [never]
   ? (args?: unknown) => Promise<Output>
   : (args: Input) => Promise<Output>;
 

waspc/data/Generator/templates/sdk/wasp/client/operations/queries/core.ts

@@ -1,19 +1,23 @@
 import { Route } from 'wasp/client'
-import type { Expand, _Awaited, _ReturnType } from 'wasp/universal/types'
-import { type Query } from '../core.js'
+import type { _Awaited, _ReturnType } from 'wasp/universal/types'
+import type { Query, InternalViewOf } from '../core.js'
 import { callOperation, makeOperationRoute } from '../internal/index.js'
 import {
   addResourcesUsedByQuery,
   getActiveOptimisticUpdates,
 } from '../internal/resources'
 
+// PRIVATE API (unsed in SDK)
 export function createQuery<BackendQuery extends GenericBackendQuery>(
   relativeQueryPath: string,
   entitiesUsed: string[]
 ): QueryFor<BackendQuery> {
   const queryRoute = makeOperationRoute(relativeQueryPath)
 
-  async function query(queryKey, queryArgs) {
+  type Q = QueryFor<BackendQuery>
+  const query: Q = async (queryArgs) => { 
+    // Assumes `addMetadataToQuery` added the `queryCacheKey` property to the query.
+    const queryKey = (query as InternalViewOf<Q>).queryCacheKey
     const serverResult = await callOperation(queryRoute, queryArgs)
     return getActiveOptimisticUpdates(queryKey).reduce(
       (result, update) => update(result),
@@ -26,28 +30,23 @@ export function createQuery<BackendQuery extends GenericBackendQuery>(
   return query
 }
 
-// PRIVATE API
-export function addMetadataToQuery(
-  query: (...args: any[]) => Promise<unknown>,
-  metadata: {
-    relativeQueryPath: string
-    queryRoute: Route
-    entitiesUsed: string[]
-  }
-): void
-
-// PRIVATE API
-export function addMetadataToQuery(
-  query,
-  { relativeQueryPath, queryRoute, entitiesUsed }
-) {
-  query.queryCacheKey = [relativeQueryPath]
-  query.route = queryRoute
-  addResourcesUsedByQuery(query.queryCacheKey, entitiesUsed)
+// PRIVATE API (used in SDK)
+export function addMetadataToQuery<Input, Output>(
+  query: Query<Input, Output>,
+  { relativeQueryPath, queryRoute, entitiesUsed }: 
+  { relativeQueryPath: string, queryRoute: Route, entitiesUsed: string[] }
+): asserts query is InternalViewOf<typeof query> {
+  const internalQuery = query as InternalViewOf<typeof query>
+
+  internalQuery.queryCacheKey = [relativeQueryPath]
+  internalQuery.route = queryRoute
+  addResourcesUsedByQuery(internalQuery.queryCacheKey, entitiesUsed)
 }
 
-export type QueryFor<BackendQuery extends GenericBackendQuery> = 
-  Query<Parameters<BackendQuery>[0], _Awaited<_ReturnType<BackendQuery>>>
+export type QueryFor<BackendQuery extends GenericBackendQuery> =
+  Parameters<BackendQuery> extends []
+    ? Query<void, _Awaited<_ReturnType<BackendQuery>>>
+    : Query<Parameters<BackendQuery>[0], _Awaited<_ReturnType<BackendQuery>>>
 
+type GenericBackendQuery = (args: never, context: any) => unknown
 
-type GenericBackendQuery = (args: never, context: any) => unknown

waspc/examples/todoApp/src/TestRpcTypes.ts

@@ -0,0 +1,102 @@
+import {
+  getTask,
+  getTasks,
+  createTask,
+  updateTaskIsDone,
+  deleteCompletedTasks,
+  toggleAllTasks,
+  getNumTasks,
+  getDate,
+  getAnything,
+  getTrueVoid,
+} from 'wasp/client/operations'
+import { Task } from 'wasp/entities'
+import { Payload } from 'wasp/server/_types'
+
+// For the details of this specification, see
+// https://github.com/wasp-lang/wasp/pull/1090#discussion_r1159732471
+
+// This should be [],
+// but I couldn't get it to work yet.
+type VoidOperationPayload = [args?: void | undefined]
+
+// When the user doesn't specify an operation payload,
+// we want to be as permissive as possible.
+type UnspecifiedOperationPayload = [args?: unknown]
+
+type TQ1 = Assert<
+  InputsAndOutputsAre<typeof getTask, [Pick<Task, 'id'>], Promise<Task>>
+>
+
+type TQ2 = Assert<
+  InputsAndOutputsAre<typeof getTasks, VoidOperationPayload, Promise<Task[]>>
+>
+
+type TQ3 = Assert<
+  InputsAndOutputsAre<typeof getNumTasks, VoidOperationPayload, Promise<number>>
+>
+
+type TQ4 = Assert<
+  InputsAndOutputsAre<typeof getDate, VoidOperationPayload, Promise<Date>>
+>
+
+type TQ5 = Assert<
+  InputsAndOutputsAre<
+    typeof getAnything,
+    UnspecifiedOperationPayload,
+    Promise<Payload>
+  >
+>
+
+type TQ6 = Assert<
+  InputsAndOutputsAre<typeof getTrueVoid, VoidOperationPayload, Promise<string>>
+>
+
+type TA1 = Assert<
+  InputsAndOutputsAre<
+    typeof createTask,
+    [Pick<Task, 'description'>],
+    Promise<Task>
+  >
+>
+
+type TA2 = Assert<
+  InputsAndOutputsAre<
+    typeof updateTaskIsDone,
+    [Pick<Task, 'id' | 'isDone'>],
+    Promise<Payload>
+  >
+>
+
+type TA3 = Assert<
+  InputsAndOutputsAre<
+    typeof deleteCompletedTasks,
+    UnspecifiedOperationPayload,
+    Promise<Payload>
+  >
+>
+
+type TA4 = Assert<
+  InputsAndOutputsAre<
+    typeof toggleAllTasks,
+    UnspecifiedOperationPayload,
+    Promise<Payload>
+  >
+>
+
+type InputsAndOutputsAre<
+  OperationType extends (...args: any[]) => any,
+  ExpectedParams,
+  ExpectedReturn
+> = {
+  params: AreEqual<Parameters<OperationType>, ExpectedParams>
+  return: AreEqual<ReturnType<OperationType>, ExpectedReturn>
+}
+
+type Assert<T extends { params: true; return: true }> = T
+
+type AreEqual<T, Expected> = T extends Expected
+  ? Expected extends T
+    ? true
+    : false
+  : false

waspc/examples/todoApp/src/actions.ts

@@ -8,7 +8,7 @@ import {
 } from "wasp/server/operations";
 import { getSomeResource } from './serverSetup.js'
 
-export const createTask: CreateTask<Pick<Task, 'description'>> = async (
+export const createTask: CreateTask<Pick<Task, 'description'>, Task> = async (
   task,
   context
 ) => {

waspc/examples/todoApp/src/queries.ts

@@ -1,6 +1,13 @@
-import { type Task } from "wasp/entities";
-import { HttpError } from "wasp/server";
-import { type GetNumTasks, type GetTask, type GetTasks, type GetDate } from "wasp/server/operations";
+import { type Task } from 'wasp/entities'
+import { HttpError } from 'wasp/server'
+import {
+  type GetNumTasks,
+  type GetTask,
+  type GetTasks,
+  type GetDate,
+  GetAnything,
+  GetTrueVoid,
+} from 'wasp/server/operations'
 
 export const getTasks: GetTasks<void, Task[]> = async (_args, context) => {
   if (!context.user) {
@@ -10,20 +17,24 @@ export const getTasks: GetTasks<void, Task[]> = async (_args, context) => {
   console.log('TEST_ENV_VAR', process.env.TEST_ENV_VAR)
 
   const Task = context.entities.Task
-  const tasks = await Task.findMany(
-    {
-      where: { user: { id: context.user.id } },
-      orderBy: { id: 'asc' },
-    }
-  )
+  const tasks = await Task.findMany({
+    where: { user: { id: context.user.id } },
+    orderBy: { id: 'asc' },
+  })
   return tasks
 }
 
-export const getNumTasks: GetNumTasks<void, number> = async (_args, context) => {
+export const getNumTasks: GetNumTasks<void, number> = async (
+  _args,
+  context
+) => {
   return context.entities.Task.count()
 }
 
-export const getTask: GetTask<Pick<Task, 'id'>, Task> = async (where, context) => {
+export const getTask: GetTask<Pick<Task, 'id'>, Task> = async (
+  where,
+  context
+) => {
   if (!context.user) {
     throw new HttpError(401)
   }
@@ -47,3 +58,11 @@ export const getTask: GetTask<Pick<Task, 'id'>, Task> = async (where, context) =
 export const getDate: GetDate<void, Date> = async () => {
   return new Date()
 }
+
+export const getAnything: GetAnything = async () => {
+  return 'anything'
+}
+
+export const getTrueVoid = (async () => {
+  return 'anything'
+}) satisfies GetTrueVoid