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

package/data/Generator/templates/sdk/wasp/server/operations/actions/types.ts

@@ -0,0 +1,35 @@
+{{={= =}=}}
+{=! TODO: This template is exactly the same at the moment as one for query
+          types, consider whether it makes sense to address this in the future. =}
+import {
+  {=# allEntities =}
+  type {= internalTypeName =},
+  {=/ allEntities =}
+  {=# shouldImportNonAuthenticatedOperation =}
+  type UnauthenticatedActionDefinition,
+  {=/ shouldImportNonAuthenticatedOperation =}
+  {=# shouldImportAuthenticatedOperation =}
+  type AuthenticatedActionDefinition,
+  {=/ shouldImportAuthenticatedOperation =}
+  type Payload,
+} from 'wasp/server/_types'
+
+{=# operations =}
+// PUBLIC API
+export type {= typeName =}<Input extends Payload = never, Output extends Payload = Payload> = 
+  {=# usesAuth =}
+  AuthenticatedActionDefinition<
+  {=/ usesAuth =}
+  {=^ usesAuth =}
+  UnauthenticatedActionDefinition<
+  {=/ usesAuth =}
+    [
+    {=# entities =}
+      {= internalTypeName =},
+    {=/ entities =}
+    ],
+    Input,
+    Output
+  >
+
+{=/ operations =}

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

@@ -0,0 +1,13 @@
+{{={= =}=}}
+// PUBLIC API
+export * from './queries/types.js'
+// PUBLIC API
+export * from './actions/types.js'
+{=# queries =}
+
+export { {= operationName =} } from './queries/index.js'
+{=/ queries =}
+{=# actions =}
+
+export { {= operationName =} } from './actions/index.js'
+{=/ actions =}

package/data/Generator/templates/sdk/wasp/server/operations/queries/index.ts

@@ -0,0 +1,42 @@
+{{={= =}=}}
+{=! TODO: This template is exactly the same at the moment as one for actions,
+          consider in the future if it is worth removing this duplication. =}
+
+{=! TODO: This will generate multiple import statements even though they're
+          importing symbols from the same file. We should improve our importing machinery
+          to support multiple imports from the same file =}
+import { prisma } from 'wasp/server'
+import {
+  type UnauthenticatedOperationFor,
+  createUnauthenticatedOperation,
+  {=# isAuthEnabled =}
+  type AuthenticatedOperationFor,
+  createAuthenticatedOperation,
+  {=/ isAuthEnabled =}
+} from '../wrappers.js'
+{=# operations =}
+{=& jsFn.importStatement =}
+{=/ operations =}
+{=# operations =}
+
+// PRIVATE API
+export type {= operationTypeName =} = typeof {= jsFn.importIdentifier =}
+
+// PUBLIC API
+{=# usesAuth =}
+export const {= operationName =}: AuthenticatedOperationFor<{= operationTypeName =}> =
+  createAuthenticatedOperation(
+{=/ usesAuth =}
+{=^ usesAuth =}
+export const {= operationName =}: UnauthenticatedOperationFor<{= operationTypeName =}> =
+  createUnauthenticatedOperation(
+{=/ usesAuth =}
+    {= jsFn.importIdentifier =},
+    {
+      {=# entities =}
+      {= name =}: prisma.{= prismaIdentifier =},
+      {=/ entities =}
+    },
+  )
+
+{=/ operations =}

package/data/Generator/templates/sdk/wasp/server/operations/queries/types.ts

@@ -0,0 +1,36 @@
+{{={= =}=}}
+{=! TODO: This template is exactly the same at the moment as one for action
+          types, consider whether it makes sense to address this in the future. =}
+
+import {
+  {=# allEntities =}
+  type {= internalTypeName =},
+  {=/ allEntities =}
+  {=# shouldImportNonAuthenticatedOperation =}
+  type UnauthenticatedQueryDefinition,
+  {=/ shouldImportNonAuthenticatedOperation =}
+  {=# shouldImportAuthenticatedOperation =}
+  type AuthenticatedQueryDefinition,
+  {=/ shouldImportAuthenticatedOperation =}
+  type Payload,
+} from 'wasp/server/_types'
+
+{=# operations =}
+// PUBLIC API
+export type {= typeName =}<Input extends Payload = never, Output extends Payload = Payload> = 
+  {=# usesAuth =}
+  AuthenticatedQueryDefinition<
+  {=/ usesAuth =}
+  {=^ usesAuth =}
+  UnauthenticatedQueryDefinition<
+  {=/ usesAuth =}
+    [
+    {=# entities =}
+      {= internalTypeName =},
+    {=/ entities =}
+    ],
+    Input,
+    Output
+  >
+
+{=/ operations =}

package/data/Generator/templates/sdk/wasp/server/operations/wrappers.ts

@@ -0,0 +1,242 @@
+{{={= =}=}}
+import { IfAny, _Awaited, _ReturnType, _Parameters } from '../../universal/types'
+
+{=# isAuthEnabled =}
+import { type AuthUser } from 'wasp/auth'
+{=/ isAuthEnabled =}
+import {
+  _Entity,
+  {=# isAuthEnabled =}
+  AuthenticatedOperationDefinition,
+  {=/ isAuthEnabled =}
+  UnauthenticatedOperationDefinition,
+  Payload,
+} from '../_types'
+
+// PRIVATE API (used in SDK)
+// Explanation:
+// - Custom `_Awaited` and `_ReturnType` - Read the comments above their
+// definitions.
+// - `Parameters<OperationDefinition> extends []` - Same reason as described here:
+// https://github.com/wasp-lang/wasp/pull/1992/files#r1583040080
+/**
+ * Constructs the unauthenticated operation's server-side API type from its
+ * definition.
+ *
+ * @template OperationDefinition The type of the unauthenticated operation's
+ * definition.
+ */
+export type UnauthenticatedOperationFor<
+  OperationDefinition extends GenericUnauthenticatedOperationDefinition
+> = Parameters<OperationDefinition> extends []
+  ? UnauthenticatedOperation<void, _Awaited<_ReturnType<OperationDefinition>>>
+  : UnauthenticatedOperation<
+      Parameters<OperationDefinition>[0],
+      _Awaited<_ReturnType<OperationDefinition>>
+    >
+
+// PRIVATE API (used in SDK)
+/**
+ * Creates the server-side API for an unauthenticated operation.
+ *
+ * @template OperationDefinition The type of the unauthenticated operation's definition.
+ * @param userOperation The unauthenticated operation's definition.
+ * @param entities The unauthenticated operation's entity map .
+ * @returns The server-side API for the provided unauthenticated operation.
+ */
+export function createUnauthenticatedOperation<
+  OperationDefinition extends GenericUnauthenticatedOperationDefinition
+>(
+  userOperation: OperationDefinition,
+  entities: EntityMapFor<OperationDefinition>
+): UnauthenticatedOperationFor<OperationDefinition> {
+  async function operation(payload: Parameters<OperationDefinition>[0]) {
+    return userOperation(payload, {
+      entities,
+    })
+  }
+  // This assertion is necessary because, when the Input is void, we want to present
+  // the function as not accepting a payload (which isn't consistent with how
+  // it's defined).
+  return operation as UnauthenticatedOperationFor<OperationDefinition>
+}
+
+{=# isAuthEnabled =}
+// PRIVATE API (used in SDK)
+// Explanation:
+// - Custom `_Awaited` and `_ReturnType` - Read the comments above their
+// definitions.
+// - `Parameters<OperationDefinition> extends []` - Same reason as described here:
+// https://github.com/wasp-lang/wasp/pull/1992/files#r1583040080
+/**
+ * Constructs the authenticated operation's server-side API type from its
+ * definition.
+ *
+ * @template OperationDefinition The type of the authenticated operation's
+ * definition.
+ */
+export type AuthenticatedOperationFor<
+  OperationDefinition extends GenericAuthenticatedOperationDefinition
+> = Parameters<OperationDefinition> extends []
+  ? AuthenticatedOperation<void, _Awaited<_ReturnType<OperationDefinition>>>
+  : AuthenticatedOperation<
+      Parameters<OperationDefinition>[0],
+      _Awaited<_ReturnType<OperationDefinition>>
+    >
+
+/**
+ * The type of the context users must pass when calling an authenticated
+ * operation's server-side API.
+ */
+export type AuthenticatedOperationContext = { user: AuthUser }
+
+// PRIVATE API (used in SDK)
+/**
+ * Creates the server-side API for an authenticated operation.
+ *
+ * @template OperationDefinition The type of the authenticated operation's definition.
+ * @param userOperation The authenticated operation's definition.
+ * @param entities The authenticated operation's entity map .
+ * @returns The server-side API for the provided authenticated operation.
+ */
+export function createAuthenticatedOperation<
+  OperationDefinition extends GenericAuthenticatedOperationDefinition
+>(
+  userOperation: OperationDefinition,
+  entities: EntityMapFor<OperationDefinition>
+): AuthenticatedOperationFor<OperationDefinition> {
+  async function operation(...args: AuthenticatedOperationArgsFor<OperationDefinition>) {
+    // To understand this function and its limitations, read
+    // https://github.com/wasp-lang/wasp/issues/2050
+    if (args.length < 1) {
+      // No arguments sent -> no user and no payload specified -> there's no way this was called correctly.
+      throw new Error(`
+        You called the operation without arguments, which is a mistake.
+        Check your definition and read the docs to understand what you need to send:
+        https://wasp.sh/docs/data-model/operations/overview
+        `
+      )
+    } else if (includesPayload(args)) {
+      // Two arguments sent -> the first argument is the payload, the second is the context.
+      const [payload, context] = args
+      return userOperation(payload as Parameters<OperationDefinition>[0], {
+        ...context,
+        entities,
+      })
+    } else {
+      // One argument sent -> the first and only argument is the user.
+      const [context] = args
+      return userOperation(undefined as Parameters<OperationDefinition>[0], {
+        ...context,
+        entities,
+      })
+    }
+  }
+
+  return operation as AuthenticatedOperationFor<OperationDefinition>
+}
+
+/**
+ * Returns a boolean carrying compiler type information about whether the
+ * provided arguments array (of an authenticated operation) includes a payload.
+ *
+ * To understand why "two arguments" means "includes payload", read
+ * https://github.com/wasp-lang/wasp/issues/2050
+ *
+ * @template Input The type of the payload the operation expects.
+ * @param args The arguments array for an authenticated operation.
+ * @returns true if the arguments array includes a payload, false otherwise.
+ */
+function includesPayload<Input>(
+  args: [AuthenticatedOperationContext] | [Input, AuthenticatedOperationContext]
+): args is [Input, AuthenticatedOperationContext] {
+  return args.length === 2
+}
+
+/**
+ * Constructs the type of the arguments array for an authenticated operation
+ * based on the type of its definition.
+ */
+type AuthenticatedOperationArgsFor<Op extends GenericAuthenticatedOperationDefinition> =
+  Parameters<AuthenticatedOperationFor<Op>>
+
+// NOTE: There's some duplication in the below types.
+// Read the discussion here to understand why before attempting to remove it:
+// https://github.com/wasp-lang/wasp/pull/2170#discussion_r1671285049
+/**
+ * Constructs the type for an authenticated operation's server-side API.
+ *
+ * @template Input The type of the payload the operation expects (must be
+ * `void` if the operation doesn't expect a payload).
+ * @template Output The type of the operation's return value.
+ */
+type AuthenticatedOperation<Input, Output> =
+  IfAny<
+    Input,
+    (args: any, context: { user: AuthUser }) => Promise<Output>,
+    AuthenticatedOperationWithNonAnyInput<Input, Output>
+  >
+
+// Read this to understand the type: https://github.com/wasp-lang/wasp/pull/1090#discussion_r1159732471
+type AuthenticatedOperationWithNonAnyInput<Input, Output> =
+  [Input] extends [never]
+  ? (args: unknown, context: { user: AuthUser }) => Promise<Output>
+  : [Input] extends [void]
+  ? (context: { user: AuthUser }) => Promise<Output>
+  : (args: Input, context: { user: AuthUser }) => Promise<Output>
+
+/**
+ * The principal type for an authenticated operation's definition (i.e., all
+ * authenticated operation definition types are a subtype of this type).
+ *
+ */
+type GenericAuthenticatedOperationDefinition = AuthenticatedOperationDefinition<
+  // NOTE(filip): Not quite sure I understand what's going on with Variance here.
+  _Entity[],
+  never,
+  Payload
+>
+
+{=/ isAuthEnabled =}
+// Read this to understand the type: https://github.com/wasp-lang/wasp/pull/2170#issue-2398830273
+/**
+ * Constructs the type for an unauthenticated operation's server-side API.
+ *
+ * @template Input The type of the payload the operation expects (must be
+ * `void` if the operation doesn't expect a payload).
+ * @template Output The type of the operation's return value.
+ */
+type UnauthenticatedOperation<Input, Output> =
+  IfAny<
+    Input,
+    (args?: any) => Promise<Output>,
+    UnauthenticatedOperationWithNonAnyInput<Input, Output>
+  >
+
+// Read this to understand the type: https://github.com/wasp-lang/wasp/pull/1090#discussion_r1159732471
+type UnauthenticatedOperationWithNonAnyInput<Input, Output> =
+  [Input] extends [never]
+  ? (args?: unknown) => Promise<Output>
+  : [Input] extends [void]
+  ? () => Promise<Output>
+  : (args: Input) => Promise<Output>
+
+/**
+ * The principal type for an unauthenticated operation's definition (i.e., all
+ * unauthenticated operation definition types are a subtype of this type).
+ *
+ */
+type GenericUnauthenticatedOperationDefinition = UnauthenticatedOperationDefinition<
+  // NOTE(filip): Not quite sure I understand what's going on with Variance here.
+  _Entity[],
+  never,
+  Payload
+>
+
+/**
+ * Queries the entity map from the type of the operation's definition.
+ *
+ * @template OperationDefinition The type of the operation's definition.
+ */
+type EntityMapFor<OperationDefinition extends GenericUnauthenticatedOperationDefinition> =
+  _Parameters<OperationDefinition>[1]["entities"]

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

@@ -0,0 +1,11 @@
+import { type Application } from 'express'
+import { Server } from 'http'
+
+// PUBLIC API
+export type ServerSetupFn = (context: ServerSetupFnContext) => Promise<void>
+
+// PRIVATE API (server)
+export type ServerSetupFnContext = {
+  app: Application,
+  server: Server,
+}

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

@@ -0,0 +1,38 @@
+{{={= =}=}}
+import { Response, RequestHandler } from 'express'
+
+{=# isAuthEnabled =}
+import { type AuthUserData } from './auth/user.js'
+{=/ isAuthEnabled =}
+
+// This is explicitly how Express expects extensions to their
+// Request and Response objects to be done.
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/5d29b9be383902b0399f26072b4590ac61ca72c5/types/express-serve-static-core/index.d.ts#L6-L15
+declare global {
+  namespace Express {
+    interface Request {
+      {=# isAuthEnabled =}
+      user?: AuthUserData | null;
+      sessionId?: string | null;
+      {=/ isAuthEnabled =}
+    }
+  }
+}
+
+/**
+ * Simple helper to give the correct types for Express handlers.
+ * We define it in the same file as our extension to Request
+ * so that it is picked up by TypeScript.
+ */
+export const defineHandler = <T extends RequestHandler>(
+  middleware: T
+): T => middleware
+
+export const sleep = (ms: number): Promise<unknown> => new Promise((r) => setTimeout(r, ms))
+
+export function redirect(res: Response, redirectUri: string)  {
+  return res
+    .status(302)
+    .setHeader("Location", redirectUri)
+    .end();
+}

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

@@ -0,0 +1,57 @@
+{{={= =}=}}
+
+import { Server } from 'socket.io'
+import { EventsMap, DefaultEventsMap } from '@socket.io/component-emitter'
+
+import { prisma } from 'wasp/server'
+{=# isAuthEnabled =}
+import { type AuthUser } from 'wasp/auth'
+{=/ isAuthEnabled =}
+
+{=& userWebSocketFn.importStatement =}
+
+// Public API
+export type WebSocketDefinition<
+  ClientToServerEvents extends EventsMap = DefaultEventsMap,
+  ServerToClientEvents extends EventsMap = DefaultEventsMap,
+  InterServerEvents extends EventsMap = DefaultEventsMap,
+  SocketData extends WaspSocketData = WaspSocketData
+> = (
+  io: Server<
+    ClientToServerEvents,
+    ServerToClientEvents,
+    InterServerEvents,
+    SocketData
+  >,
+  context: {
+    entities: {
+      {=# allEntities =}
+      {= name =}: typeof prisma.{= prismaIdentifier =},
+      {=/ allEntities =}
+    }
+  }
+) => Promise<void> | void
+
+// PUBLIC API
+export interface WaspSocketData {
+  {=# isAuthEnabled =}
+  user?: AuthUser
+  {=/ isAuthEnabled =}
+}
+
+// PRIVATE API (framework)
+export type ServerType = Parameters<WebSocketFn>[0]
+
+// PRIVATE API (sdk)
+export type ClientToServerEvents = Events[0]
+// PRIVATE API (sdk)
+export type ServerToClientEvents = Events[1]
+
+type WebSocketFn = typeof {= userWebSocketFn.importIdentifier =}
+type Events = ServerType extends Server<
+  infer ClientToServerEvents,
+  infer ServerToClientEvents
+>
+  ? [ClientToServerEvents, ServerToClientEvents]
+  : [DefaultEventsMap, DefaultEventsMap]
+

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

@@ -0,0 +1,102 @@
+{
+  "compilerOptions": {
+    /* Basic options */
+    "target": "esnext",
+    "jsx": "preserve",
+    "lib": [
+      "esnext",
+      "dom",
+      "DOM.Iterable"
+    ],
+    "skipLibCheck": true,
+    "allowJs": true,
+    "rootDir": ".",
+    "outDir": "dist",
+
+    /* Strictness and type checking */
+    /*
+       User code was compiled using `"strict": true`, so we know we can use it
+       here as well. We override some of strict's options because parts of the SDK
+       code don't respect them. This only makes the SDK ruleset more permissive than
+       the user's ruleset. Therefore, we can sefely include users code inside the
+       SDK without casuing errors during the SDK build step.
+       Reference: https://github.com/wasp-lang/wasp/issues/1938
+    */
+    "strict": true,
+    "useUnknownInCatchVariables": false,
+    "noImplicitAny": false,
+    "strictPropertyInitialization": false,
+    /*
+       The following two properties are disabled because we don't
+       yet want to force user code to use them.
+       Reference: https://github.com/wasp-lang/wasp/issues/2655
+    */
+    "noUncheckedIndexedAccess": false,
+    "noImplicitOverride": false,
+
+    /* DX */
+    "declaration": true, // Allows users to consume the SDK as a library, enables autocomplete
+    "declarationMap": true, // Makes go-to-definition go to source instead of type definitions
+    "sourceMap": true, // Needed for debugging
+
+    /* Modules */
+    "module": "esnext",
+    "esModuleInterop": true,
+    // TODO: Enable this once we enable it for users:
+    // https://github.com/wasp-lang/wasp/issues/2654
+    "resolveJsonModule": false,
+    /*
+       The `isolatedModules` flag tells typescript to throw errors on code that
+       doesn't work with bundlers:
+         - The user code must enable it because Wasp bundles user code when bundling
+        server code and web app code (which directly import the user code).
+         - The SDK code must disable it because parts of the SDK code rely on
+        such features. Since we build the SDK with TSC before bundling it,
+        these features don't cause problems.
+      More details in https://github.com/wasp-lang/wasp/issues/2150
+    */
+    "isolatedModules": false,
+    // `verbatimModuleSyntax` is disabled because we don't yet want to
+    // force user code into using `type` imports.
+    "verbatimModuleSyntax": false,
+    "moduleDetection": "force", // Assume all files are modules
+    /*
+      - We want to allow users to use extensionless and directory imports.
+      - We want users to import stuff from the SDK with `wasp/something`, and we
+        don't want to do extra processing on those imports (for now).
+
+      These requirements force us to bundle user code and, because we copy user
+      code into the SDK code, they force us to bundle the SDK too.
+
+      We currently bundle the SDK in a very hacky way (indirectly while bundling
+      the server and client): https://github.com/wasp-lang/wasp/issues/2150
+      Regardless of how we do it, the SDK code is eventually bundled, so this
+      `tsconfig.json` file must reflect that (which means `moduleResolution:
+      bundler`).
+    */
+    "moduleResolution": "bundler",
+    "types": [
+      /*
+         This is needed to properly support Vitest testing with jest-dom matchers.
+         Types for jest-dom are not recognized automatically and Typescript complains
+         about missing types e.g. when using `toBeInTheDocument` and other matchers.
+      */
+      "@testing-library/jest-dom"
+    ],
+    /*
+       The `incremental` option enables faster SDK compilation, less Vite HMR
+       messages and it prevent unnecessary full-page reloads when using Vite HMR.
+       While this is great, we still want to dig deeper at some point to understand
+       better why Vite HMR misbehaves when the SDK is recompiled:
+       https://github.com/wasp-lang/wasp/issues/1934
+    */
+    "incremental": true,
+  },
+  "include": [
+    "."
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/data/Generator/templates/sdk/wasp/universal/ansiColors.ts

@@ -0,0 +1,14 @@
+export const colors = {
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+} as const;
+
+export const resetColor = "\x1b[0m";
+
+// PRIVATE API (SDK, client)
+// Used with console.log() to colorize the output
+// Example: console.log(getColorizedConsoleFormatString('red'), 'This is red text');
+export function getColorizedConsoleFormatString(colorKey: keyof typeof colors): string {
+  const color = colors[colorKey];
+  return `${color}%s${resetColor}`;
+}

package/data/Generator/templates/sdk/wasp/universal/predicates.ts

@@ -0,0 +1,3 @@
+export function isNotNull<T>(value: T | null): value is T {
+  return value !== null;
+}

package/data/Generator/templates/sdk/wasp/universal/types.ts

@@ -0,0 +1,74 @@
+// This is a helper type used exclusively for DX purposes. It's a No-op for the
+// compiler, but expands the type's representatoin in IDEs (i.e., inlines all
+// type constructors) to make it more readable for the user.
+//
+// It expands this SO answer to functions: https://stackoverflow.com/a/57683652
+export type Expand<T> = T extends (...args: infer A) => infer R
+  ? (...args: A) => R
+  : T extends infer O
+  ? { [K in keyof O]: O[K] }
+  : never
+
+// TypeScript's native Awaited type exhibits strange behavior in VS Code (see
+// https://github.com/wasp-lang/wasp/pull/1090#discussion_r1159687537 for
+// details). Until it's fixed, we're using our own type for this.
+//
+// TODO: investigate further. This most likely has something to do with an
+// unsatisfied 'extends' constraints. A mismatch is probably happening with
+// function parameter types and/or return types (check '_ReturnType' below for
+// more).
+export type _Awaited<T> = T extends Promise<infer V>
+  ? _Awaited<V>
+  : T
+
+// TypeScript's native ReturnType does not work for functions of type '(...args:
+// never[]) => unknown' (and that's what operations currently use).
+//
+// TODO: investigate how to properly specify the 'extends' constraint for function
+// type (i.e., any vs never and unknown) and stick with that. Take DX into
+// consideration.
+export type _ReturnType<T extends (...args: never[]) => unknown> =
+  T extends (...args: never[]) => infer R ? R : never
+
+
+// Returns elements of an array except the first one.
+export type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
+
+
+// Source: https://stackoverflow.com/a/55541672
+export type IfAny<Value, Then, Else> = 0 extends (1 & Value) ? Then : Else;
+
+// If users use JS to define their operations and destructure object arguments,
+// Wasp's TS helper types can't infer correct types due to this TS bug:
+// https://github.com/microsoft/TypeScript/issues/52768 
+// The bug breaks the built-in `Parameters` helper, so we introduce a custom version
+// that works with Wasp's TS helper types like `EntityMapFor`.
+export type _Parameters<T extends (...args: any) => any> = T extends (
+  firstParam: infer FirstParam,
+  ...rest: infer Rest
+) => any
+  ? [FirstParam, ...Rest]
+  : Parameters<T>;
+
+/**
+ * 
+ * Exact ensures a type has exactly the properties of another type.
+ * Helps with simulating excess property checking for generics in function definitions.
+ * 
+ * Inspired by: https://stackoverflow.com/questions/49580725/is-it-possible-to-restrict-typescript-object-to-contain-only-properties-define
+ * 
+ * @template T - The base type that defines the allowed properties
+ * @template U - The type to be constrained (must extend T)
+ * 
+ * @example
+ * // User can no longer add properties outside of UserSignupFields to T
+ * function defineUserSignupFields<T extends UserSignupFields>(
+ *   fields: Exact<UserSignupFields, T>
+ * ): T {
+ *   return fields
+ * }
+ */
+export type Exact<T, U extends T = T> = U & {
+  [P in Exclude<keyof U, keyof T>]: never;
+}
+