@wasp.sh/wasp-cli-darwin-x64-unknown 0.20.0

package/data/Generator/templates/sdk/wasp/core/auth.ts

@@ -0,0 +1,40 @@
+import { getSessionAndUserFromBearerToken } from 'wasp/auth/session'
+import { createInvalidCredentialsError } from 'wasp/auth/utils'
+import { defineHandler } from 'wasp/server/utils'
+
+/**
+ * Auth middleware
+ *
+ * If the request includes an `Authorization` header it will try to authenticate the request,
+ * otherwise it will let the request through.
+ *
+ * - If authentication succeeds it sets `req.sessionId` and `req.user`
+ *   - `req.user` is the user that made the request and it's used in
+ *      all Wasp features that need to know the user that made the request.
+ *   - `req.sessionId` is the ID of the session that authenticated the request.
+ * - If the request is not authenticated, it throws an error.
+ */
+const auth = defineHandler(async (req, res, next) => {
+  const authHeader = req.get('Authorization')
+  // NOTE(matija): for now we let tokenless requests through and make it operation's
+  // responsibility to verify whether the request is authenticated or not. In the future
+  // we will develop our own system at Wasp-level for that.
+  if (!authHeader) {
+    req.sessionId = null
+    req.user = null
+    return next()
+  }
+
+  const sessionAndUser = await getSessionAndUserFromBearerToken(req)
+
+  if (sessionAndUser === null) {
+    throw createInvalidCredentialsError()
+  }
+
+  req.sessionId = sessionAndUser.session.id
+  req.user = sessionAndUser.user
+
+  next()
+})
+
+export default auth

package/data/Generator/templates/sdk/wasp/core/serialization/custom-register.ts

@@ -0,0 +1,21 @@
+import type { WaspInternal_CustomSerializableJSONValue_Register } from "superjson"
+
+/*
+  This is a workaround for declaring custom types through side-effects in
+  TypeScript. This way a bare import, like `import "./prisma"` will register
+  itself as a custom serialization in the type-level, like it does at the
+  runtime-level.
+
+  This declaration creates an empty interface. Implementations of custom
+  serialization types can extend this interface through augmentation
+  (https://www.typescriptlang.org/docs/handbook/declaration-merging.html#merging-interfaces).
+  We can later inspect this interface to see which custom types are registered.
+
+  This approach is copied from TanStack Router's `Register` interface
+  https://github.com/TanStack/router/blob/v1.124.1/docs/router/framework/react/guide/creating-a-router.md#router-type-safety
+*/
+declare module "superjson" {
+  interface WaspInternal_CustomSerializableJSONValue_Register {}
+}
+
+export type CustomSerializableJSONValue = WaspInternal_CustomSerializableJSONValue_Register[keyof WaspInternal_CustomSerializableJSONValue_Register]

package/data/Generator/templates/sdk/wasp/core/serialization/index.ts

@@ -0,0 +1,56 @@
+{{={= =}=}}
+import { deserialize, serialize } from "superjson"
+import { CustomSerializableJSONValue } from "./custom-register"
+
+{=# entitiesExist =}
+import "./prisma"
+{=/ entitiesExist =}
+
+export type Payload = void | SuperJSONValue;
+
+// The part below was copied from SuperJSON and slightly modified:
+// https://github.com/blitz-js/superjson/blob/ae7dbcefe5d3ece5b04be0c6afe6b40f3a44a22a/src/types.ts
+//
+// We couldn't use SuperJSON's types directly because:
+//   1. They have a weird quirk that turns `SuperJSONValue` into `any`.
+//      See why here:
+//      https://github.com/blitz-js/superjson/pull/36#issuecomment-669239876
+//   2. We need to add our own custom types to the serialization process.
+//
+// We changed the code as little as possible to make future comparisons easier.
+export type JSONValue = PrimitiveJSONValue | JSONArray | JSONObject;
+
+export interface JSONObject {
+  [key: string]: JSONValue;
+}
+
+type PrimitiveJSONValue = string | number | boolean | undefined | null;
+
+export interface JSONArray extends Array<JSONValue> {}
+
+// Removed `Symbol` since we don't explicitly register any symbol to be serialized
+// Added custom types from `CustomSerializableJSONValue`
+export type SerializableJSONValue =
+  | Set<SuperJSONValue>
+  | Map<SuperJSONValue, SuperJSONValue>
+  | undefined
+  | bigint
+  | Date
+  | RegExp
+  | CustomSerializableJSONValue;
+
+// Here's where we excluded `ClassInstance` (which was `any`) from the union.
+export type SuperJSONValue =
+  | JSONValue
+  | SerializableJSONValue
+  | SuperJSONArray
+  | SuperJSONObject;
+
+export interface SuperJSONArray extends Array<SuperJSONValue> {}
+
+export interface SuperJSONObject {
+  [key: string]: SuperJSONValue;
+}
+
+export { deserialize, serialize }
+

package/data/Generator/templates/sdk/wasp/core/serialization/prisma.ts

@@ -0,0 +1,54 @@
+import { Prisma } from "@prisma/client"
+import { registerCustom } from "superjson"
+import "./custom-register"
+
+// This file is only added if there are (Prisma) entities in the AppSpec.
+
+/*
+  == ADDING SUPPORT FOR PRISMA DECIMAL TYPE ==
+  We add support for the Decima Prisma type as listed here:
+  https://www.prisma.io/docs/orm/prisma-client/special-fields-and-types
+*/
+
+/*
+  == Why this strange declaration? ==
+
+  You can usually get `Decimal` from Prisma in two ways:
+  a. `import("@prisma/client").Prisma.Decimal`
+  b. `import("@prisma/client/runtime/library").Decimal`
+
+  The problem is that (a) is only available in the case that the Prisma schema is using Decimal
+  somewhere, and doesn't exist at all otherwise, not even as `undefined`. And (b) is always
+  available, but the code at `@prisma/client/runtime/library` fails when imported from the
+  client (and this file can be imported from either client or server).
+
+  What we do here is tell TypeScript that `Prisma` (option a) can have an optional `Decimal`
+  property, and give it the `Decimal` type that we take from option (b). Importantly, we only
+  do a type import from (b) so we don't trigger the runtime error when importing from the client.
+*/
+type DecimalClass = typeof import("@prisma/client/runtime/library").Decimal;
+type DecimalInstance = InstanceType<DecimalClass>;
+const Decimal = (Prisma as { Decimal?: DecimalClass }).Decimal;
+
+/*
+  And finally, if we have the `Decimal` type because the Prisma schema is using it,
+  we register it as a custom type with SuperJSON.
+  Based on https://github.com/flightcontrolhq/superjson/blob/v2.2.2/README.md#decimaljs--prismadecimal
+*/
+if (Decimal) {
+  registerCustom<DecimalInstance, string>(
+    {
+      isApplicable: (v): v is DecimalInstance => Decimal.isDecimal(v),
+      serialize: (v) => v.toJSON(),
+      deserialize: (v) => new Decimal(v),
+    },
+    "prisma.decimal",
+  );
+}
+
+// We add the `Decimal` to this interface so that it is registered as a custom serialization type
+declare module "superjson" {
+  interface WaspInternal_CustomSerializableJSONValue_Register {
+    Decimal: DecimalInstance;
+  }
+}

package/data/Generator/templates/sdk/wasp/core/storage.ts

@@ -0,0 +1,50 @@
+export type DataStore = {
+  getPrefixedKey(key: string): string
+  set(key: string, value: unknown): void
+  get(key: string): unknown
+  remove(key: string): void
+  clear(): void
+}
+
+function createLocalStorageDataStore(prefix: string): DataStore {
+  function getPrefixedKey(key: string): string {
+    return `${prefix}:${key}`
+  }
+
+  return {
+    getPrefixedKey,
+    set(key, value) {
+      ensureLocalStorageIsAvailable()
+      localStorage.setItem(getPrefixedKey(key), JSON.stringify(value))
+    },
+    get(key) {
+      ensureLocalStorageIsAvailable()
+      const value = localStorage.getItem(getPrefixedKey(key))
+      try {
+        return value ? JSON.parse(value) : undefined
+      } catch (e: any) {
+        return undefined
+      }
+    },
+    remove(key) {
+      ensureLocalStorageIsAvailable()
+      localStorage.removeItem(getPrefixedKey(key))
+    },
+    clear() {
+      ensureLocalStorageIsAvailable()
+      Object.keys(localStorage).forEach((key) => {
+        if (key.startsWith(prefix)) {
+          localStorage.removeItem(key)
+        }
+      })
+    },
+  }
+}
+
+export const storage = createLocalStorageDataStore('wasp')
+
+function ensureLocalStorageIsAvailable(): void {
+  if (!window.localStorage) {
+    throw new Error('Local storage is not available.')
+  }
+}

package/data/Generator/templates/sdk/wasp/dev/index.ts

@@ -0,0 +1,19 @@
+{{={= =}=}}
+/**
+ * Code found in this module is not meant to be used in user's server or client
+ * code. It is used by the Wasp tooling e.g. in the Tailwind config to resolve
+ * paths to the project root directory.
+ */
+
+import { join as joinPaths } from 'path'
+
+// PUBLIC API
+/**
+ * Wasp runs the client code in the `web-app` directory which is nested in the
+ * .wasp/out/web-app directory. This function resolves a project root dir path
+ * to be relative to the `web-app` directory i.e. `../../../projectDirPath`.
+ */
+export function resolveProjectPath(path: string): string {
+  const waspProjectDirFromWebAppDir = '{= waspProjectDirFromWebAppDir =}'
+  return joinPaths(waspProjectDirFromWebAppDir, path)
+}

package/data/Generator/templates/sdk/wasp/entities/index.ts

@@ -0,0 +1,28 @@
+{{={= =}=}}
+import {
+  {=# entities =}
+  type {= name =},
+  {=/ entities =}
+} from "@prisma/client"
+
+export {
+  {=# entities =}
+  type {= name =},
+  {=/ entities =}
+  {=# isAuthEnabled =}
+  type {= authEntityName =},
+  type {= authIdentityEntityName =},
+  {=/ isAuthEnabled =}
+} from "@prisma/client"
+
+export type Entity = 
+  {=# entities =}
+  | {= name =}
+  {=/ entities =}
+  | never
+
+export type EntityName = 
+  {=# entities =}
+  | "{= name =}"
+  {=/ entities =}
+  | never

package/data/Generator/templates/sdk/wasp/env/index.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod'
+
+// PUBLIC API
+export function defineEnvValidationSchema<Schema extends z.ZodObject<any>>(
+  schema: Schema,
+): Schema {
+  return schema
+}
+

package/data/Generator/templates/sdk/wasp/env/validation.ts

@@ -0,0 +1,38 @@
+import * as z from 'zod'
+
+import { getColorizedConsoleFormatString } from 'wasp/universal/ansiColors'
+
+const redColorFormatString = getColorizedConsoleFormatString('red');
+
+// PRIVATE API (SDK)
+export function ensureEnvSchema<Schema extends z.ZodTypeAny>(
+  data: unknown,
+  schema: Schema
+): z.infer<Schema> {
+  const result = getValidatedEnvOrError(data, schema)
+  if (result.success) {
+    return result.data
+  } else {
+    console.error(`${redColorFormatString}${formatZodEnvErrors(result.error.issues)}`)
+    throw new Error('Error parsing environment variables')
+  }
+}
+
+// PRIVATE API (SDK, Vite config)
+export function getValidatedEnvOrError<Schema extends z.ZodTypeAny>(
+  env: unknown,
+  schema: Schema
+): z.SafeParseReturnType<unknown, z.infer<Schema>> {
+  return schema.safeParse(env)
+}
+
+// PRIVATE API (SDK, Vite config)
+export function formatZodEnvErrors(issues: z.ZodIssue[]): string {
+  const errorOutput = ['', '══ Env vars validation failed ══', '']
+  for (const error of issues) {
+    errorOutput.push(` - ${error.message}`)
+  }
+  errorOutput.push('')
+  errorOutput.push('════════════════════════════════')
+  return errorOutput.join('\n')
+}

package/data/Generator/templates/sdk/wasp/package.json

@@ -0,0 +1,152 @@
+{{={= =}=}}
+{
+  "name": "wasp",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+      "build": "tsc && node ./scripts/copy-assets.js",
+      "test": "echo \"Error: no test specified\" && exit 1",
+      "types": "tsc --declaration --emitDeclarationOnly --stripInternal --declarationDir dist"
+    },
+  {=! IMPORTANT: If you modify this list, remember to update the spreadsheet at =}
+  {=! https://docs.google.com/spreadsheets/d/1QW-_16KRGTOaKXx9NYUtjk6m2TQ0nUMOA74hBthTH3g/edit =}
+  "exports": {
+      {=! todo(filip): Check all exports when done with SDK generation =}
+      {=!  Some of the statements in the comments might become incorrect. =}
+      {=!  "our code" means: "web-app", "server" or "SDK", or "some combination of the three". =}
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./core/storage": "./dist/core/storage.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./core/serialization": "./dist/core/serialization/index.js",
+      "./core/auth": "./dist/core/auth.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/helpers/user": "./dist/auth/helpers/user.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/session": "./dist/auth/session.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/user": "./dist/auth/user.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/providers/types": "./dist/auth/providers/types.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/types": "./dist/auth/types.js",
+      {=!  Used by users, documented. =}
+      "./auth/utils": "./dist/auth/utils.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/password": "./dist/auth/password.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/jwt": "./dist/auth/jwt.js",
+      {=!  Used by user, documented. =}
+      "./auth/validation": "./dist/auth/validation.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./auth/pages/createAuthRequiredPage": "./dist/auth/pages/createAuthRequiredPage.jsx",
+      {=!  Used by our framework code (Websockets), undocumented (but accessible) for users. =}
+      "./api/events": "./dist/api/events.js",
+      {=!  Used by users, documented. =}
+      "./operations": "./dist/operations/index.js",
+      {=!  If we import a symbol like "import something form 'wasp/something'", we must =}
+      {=!  expose it here (which leaks it to our users). We could avoid this by =}
+      {=!  using relative imports inside SDK code (instead of library imports), =}
+      {=!  but I didn't have time to implement it. =}
+      "./src/*": "./dist/src/*.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./operations/*": "./dist/operations/*",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./universal/url": "./dist/universal/url.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./universal/types": "./dist/universal/types.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./universal/validators": "./dist/universal/validators.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./universal/ansiColors": "./dist/universal/ansiColors.js",
+      {=!  Parts are used by users, documented. Parts are probably used by our code, undocumented (but accessible). =}
+      "./server/utils": "./dist/server/utils.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./server/auth/email": "./dist/server/auth/email/index.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./client/test/*": "./dist/client/test/*.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./server/crud/*": "./dist/server/crud/*.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./server/email/core/types": "./dist/server/email/core/types.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./server/auth/email/utils": "./dist/server/auth/email/utils.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      "./server/jobs/*": "./dist/server/jobs/*.js",
+      {=!  Used by our code, undocumented (but accessible) for users. =}
+      {=!  Todo(filip): This export becomes problematic once we start supporting different executors =}
+      "./server/jobs/core/pgBoss": "./dist/server/jobs/core/pgBoss/index.js",
+
+      {=! Used by the framework client code, reconsider during refactoring. =}
+      "./client/webSocket/WebSocketProvider": "./dist/client/webSocket/WebSocketProvider.jsx",
+      {=! Still needed, reconsider during refactoring. =}
+      "./server/types": "./dist/server/types/index.js",
+      {=! Used by the framework server code, reconsider during refactoring. =}
+      "./server/middleware": "./dist/server/middleware/index.js",
+
+      {=! ================= NEW API HERE =================== =}
+      {=! Public: { config, prisma, type ServerSetupFn, HttpError, type DbSeedFn, type MiddlewareConfigFn } =}
+      {=! Private: [] =}
+      "./server": "./dist/server/index.js",
+      {=! Public: { type MyApiRoute1, type MyApiRoute2, ... }  =}
+      {=! Private: [] =}
+      "./server/api": "./dist/server/api/index.js",
+      {=! Public: { api }  =}
+      {=! Private: [sdk] =}
+      "./client/api": "./dist/api/index.js",
+      {=! Public: { type ServerToClientPayload, type ClientToServerPayload, useSocket, useSocketListener } =}
+      {=! Private: [] =}
+      "./client/webSocket": "./dist/client/webSocket/index.js",
+      {=! Public: { type WebSocketDefinition, type WaspSocketData } =}
+      {=! Private: [server, sdk] =}
+      "./server/webSocket": "./dist/server/webSocket/index.js",
+      "./entities": "./dist/entities/index.js",
+      "./auth": "./dist/auth/index.js",
+      "./auth/providers": "./dist/auth/providers/index.js",
+      "./client/auth": "./dist/client/auth/index.js",
+      "./client/operations": "./dist/client/operations/index.js",
+      "./server/auth": "./dist/server/auth/index.js",
+      "./server/crud": "./dist/server/crud/index.js",
+      "./client/crud": "./dist/client/crud/index.js",
+      "./server/email": "./dist/server/email/index.js",
+      "./server/jobs": "./dist/server/jobs/index.js",
+      "./server/operations": "./dist/server/operations/index.js",
+      "./client/router": "./dist/client/router/index.js",
+      "./client/test": "./dist/client/test/index.js",
+      "./client/hooks": "./dist/client/hooks.js",
+      "./client": "./dist/client/index.js",
+      "./dev": "./dist/dev/index.js",
+      "./env": "./dist/env/index.js",
+      {=! Private: [client] =}
+      "./env/validation": "./dist/env/validation.js",
+      {=! Private: [client, sdk] =}
+      "./client/env/schema": "./dist/client/env/schema.js",
+
+      {=! todo(filip): Fixes below are for type errors in 0.13.1, remove ASAP =}
+      {=! Used by our code (SDK for full-stack type safety), undocumented (but accessible) for users. =}
+      "./client/operations/rpc": "./dist/client/operations/rpc.js",
+      "./server/operations/actions":  "./dist/server/operations/actions/index.js",
+      "./server/operations/queries": "./dist/server/operations/queries/index.js",
+      "./server/_types": "./dist/server/_types/index.js"
+
+   },
+   {=!
+     TypeScript doesn't care about the redirects we define above in "exports" field; those
+     are used only in runtime. TypeScript instead follows exact path as stated in an import when
+     trying to find the type declarations. Therefore, when "exports" redirect doesn't match the path
+     it redirects to, we need to also let TypeScript know about it, and that can be done with
+     `typesVersions` field below.
+   =}
+   "typesVersions": {
+     "*": {
+       "client/api": ["api/index.ts"]
+     }
+   },
+   "license": "ISC",
+    "include": [
+      "src/**/*"
+   ],
+   {=& depsChunk =},
+   {=& devDepsChunk =},
+   {=& peerDepsChunk =}
+}

package/data/Generator/templates/sdk/wasp/prisma-runtime-library.d.ts

@@ -0,0 +1,17 @@
+// Without this import, Prisma types are resolved incorrectly.
+import * as runtime from '@prisma/client/runtime';
+
+// Prisma generated types which we use as default input and output types for CRUD
+// operations internally use interfaces for some types.
+// Our SuperJSON serialization types throw a type error when used with interfaces
+// because interfaces don't have an implicit index signature.
+// Read more https://github.com/microsoft/TypeScript/issues/15300#issuecomment-1320528385
+// Here's a playground demonstrating the behaviour difference: https://tsplay.dev/interface_vs_type_index
+
+// Luckily, only one interface is problematic for us: `FieldRef` which we can augment
+// to have an index signature:
+declare module '@prisma/client/runtime/library.js' {
+  export interface FieldRef<Model, FieldType> {
+    [key: string]: any;
+  }
+}

package/data/Generator/templates/sdk/wasp/scripts/copy-assets.js

@@ -0,0 +1,14 @@
+import * as fs from "node:fs/promises"
+import * as path from "node:path"
+
+const base = path.resolve(import.meta.dirname, "..");
+
+const globs = ["./auth/forms/**/*.css"];
+
+for await (const file of fs.glob(globs, { cwd: base })) {
+  const src = path.join(base, file);
+  const dest = path.join(base, "dist", file);
+
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  await fs.copyFile(src, dest);
+}

package/data/Generator/templates/sdk/wasp/server/HttpError.ts

@@ -0,0 +1,30 @@
+export class HttpError extends Error {
+  public statusCode: number
+  public data: unknown
+
+  constructor(
+    statusCode: number,
+    message?: string,
+    data?: Record<string, unknown>,
+    options?: ErrorOptions
+  ) {
+    super(message, options)
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, HttpError)
+    }
+
+    this.name = this.constructor.name
+
+    if (
+      !(Number.isInteger(statusCode) && statusCode >= 400 && statusCode < 600)
+    ) {
+      throw new Error('statusCode has to be integer in range [400, 600).')
+    }
+    this.statusCode = statusCode
+
+    if (data) {
+      this.data = data
+    }
+  }
+}

package/data/Generator/templates/sdk/wasp/server/_types/index.ts

@@ -0,0 +1,105 @@
+{{={= =}=}}
+import { type Expand } from 'wasp/universal/types'
+import { type Request, type Response } from 'express'
+import {
+  type ParamsDictionary as ExpressParams,
+  type Query as ExpressQuery,
+} from 'express-serve-static-core'
+import { prisma } from 'wasp/server'
+{=# isAuthEnabled =}
+import { type AuthUser } from 'wasp/auth'
+{=/ isAuthEnabled =}
+import { type _Entity } from './taggedEntities'
+import { type Payload } from 'wasp/core/serialization'
+
+export * from "./taggedEntities"
+export * from "wasp/core/serialization"
+
+export type UnauthenticatedQueryDefinition<
+  Entities extends _Entity[],
+  Input extends Payload,
+  Output extends Payload
+> = UnauthenticatedOperationDefinition<Entities, Input, Output>
+
+export type UnauthenticatedActionDefinition<
+  Entities extends _Entity[],
+  Input extends Payload,
+  Output extends Payload
+> = UnauthenticatedOperationDefinition<Entities, Input, Output>
+
+{=# isAuthEnabled =}
+export type AuthenticatedQueryDefinition<
+  Entities extends _Entity[],
+  Input extends Payload,
+  Output extends Payload
+> = AuthenticatedOperationDefinition<Entities, Input, Output>
+
+export type AuthenticatedActionDefinition<
+  Entities extends _Entity[],
+  Input extends Payload,
+  Output extends Payload
+> = AuthenticatedOperationDefinition<Entities, Input, Output>
+
+export type AuthenticatedOperationDefinition<
+  Entities extends _Entity[],
+  Input extends Payload,
+  Output extends Payload
+> = (
+  args: Input,
+  context: ContextWithUser<Entities>
+) => Output | Promise<Output>
+
+export type AuthenticatedApi<
+  Entities extends _Entity[],
+  Params extends ExpressParams,
+  ResBody,
+  ReqBody,
+  ReqQuery extends ExpressQuery,
+  Locals extends Record<string, any>
+> = (
+  req: Request<Params, ResBody, ReqBody, ReqQuery, Locals>,
+  res: Response<ResBody, Locals>,
+  context: ContextWithUser<Entities>,
+) => void
+
+{=/ isAuthEnabled =}
+export type UnauthenticatedOperationDefinition<
+  Entities extends _Entity[],
+  Input extends Payload,
+  Output extends Payload
+> = (args: Input, context: Context<Entities>) => Output | Promise<Output>
+
+export type Api<
+  Entities extends _Entity[],
+  Params extends ExpressParams,
+  ResBody,
+  ReqBody,
+  ReqQuery extends ExpressQuery,
+  Locals extends Record<string, any>
+> = (
+  req: Request<Params, ResBody, ReqBody, ReqQuery, Locals>,
+  res: Response<ResBody, Locals>,
+  context: Context<Entities>,
+) => void
+
+export type EntityMap<Entities extends _Entity[]> = {
+  [EntityName in Entities[number]["_entityName"]]: PrismaDelegate[EntityName]
+}
+
+export type PrismaDelegate = {
+  {=# entities =}
+  "{= name =}": typeof prisma.{= prismaIdentifier =},
+  {=/ entities =}
+}
+
+type Context<Entities extends _Entity[]> = Expand<{
+  entities: Expand<EntityMap<Entities>>
+}>
+
+{=# isAuthEnabled =}
+type ContextWithUser<Entities extends _Entity[]> = Expand<
+  Context<Entities> & { user?: AuthUser }
+>
+
+export type { ProviderName } from 'wasp/auth/utils'
+{=/ isAuthEnabled =}