@wasp.sh/wasp-cli-darwin-x64-unknown 0.25.0 → 0.26.0

package/data/Generator/templates/sdk/wasp/{auth → server/auth}/utils.ts

@@ -1,55 +1,38 @@
 {{={= =}=}}
-import { hashPassword } from './password.js'
-import { prisma, HttpError } from '../server/index.js'
-import { sleep } from '../server/utils.js'
 import {
-  type {= userEntityUpper =},
-  type {= authEntityUpper =},
-  type {= authIdentityEntityUpper =},
-} from '../entities/index.js'
+  getErrorMessage,
+  throwValidationError,
+  type ProviderId,
+  type ProviderName,
+  type PossibleProviderData,
+} from '@wasp.sh/lib-sdk-core'
+export { doFakeWork, createInvalidCredentialsError, sanitizeAndSerializeProviderData } from '@wasp.sh/lib-sdk-core/node'
+
+import { ensurePasswordIsHashed } from '@wasp.sh/lib-sdk-core/node'
+import { prisma, HttpError } from '../index.js'
+import type {
+  {= userEntityUpper =},
+  {= authEntityUpper =},
+  {= authIdentityEntityUpper =},
+} from '../../entities/index.js'
 import { Prisma } from '@prisma/client';
 
-import { throwValidationError } from './validation.js'
-
-import { type UserSignupFields, type PossibleUserFields } from './providers/types.js'
-
-// PUBLIC API
-export type EmailProviderData = {
-  hashedPassword: string;
-  isEmailVerified: boolean;
-  emailVerificationSentAt: string | null;
-  passwordResetSentAt: string | null;
-}
-
-// PUBLIC API
-export type UsernameProviderData = {
-  hashedPassword: string;
-}
-
-// PUBLIC API
-export type OAuthProviderData = {}
-
-// PRIVATE API
-/**
- * This type is used for type-level programming e.g. to enumerate
- * all possible provider data types.
- * 
- * The keys of this type are the names of the providers and the values
- * are the types of the provider data.
- */
-export type PossibleProviderData = {
-  email: EmailProviderData;
-  username: UsernameProviderData;
-  discord: OAuthProviderData;
-  slack: OAuthProviderData;
-  google: OAuthProviderData;
-  keycloak: OAuthProviderData;
-  github: OAuthProviderData;
-  microsoft: OAuthProviderData;
-}
-
-// PUBLIC API
-export type ProviderName = keyof PossibleProviderData
+import type { UserSignupFields, PossibleUserFields } from '../../auth/providers/types.js'
+
+// Runtime-agnostic provider data code, re-exported here because it's part of
+// the server-side auth API surface (e.g. through `wasp/server/auth`).
+export {
+  createProviderId,
+  normalizeProviderUserId,
+  getProviderData,
+  getProviderDataWithPassword,
+  type ProviderId,
+  type ProviderName,
+  type PossibleProviderData,
+  type EmailProviderData,
+  type UsernameProviderData,
+  type OAuthProviderData,
+} from '@wasp.sh/lib-sdk-core'
 
 // PRIVATE API
 export const contextWithUserEntity = {
@@ -60,61 +43,8 @@ export const contextWithUserEntity = {
 
 // PRIVATE API
 export const authConfig = {
-  failureRedirectPath: "{= failureRedirectPath =}",
-  successRedirectPath: "{= successRedirectPath =}",
-}
-
-// PUBLIC API
-/**
- * ProviderId uniquely identifies an auth identity e.g. 
- * "email" provider with user id "test@test.com" or
- * "google" provider with user id "1234567890".
- * 
- * We use this type to avoid passing the providerName and providerUserId
- * separately. Also, we can normalize the providerUserId to make sure it's
- * consistent across different DB operations.
- */
-export type ProviderId = {
-  providerName: ProviderName;
-  providerUserId: string;
-}
-
-// PUBLIC API
-export function createProviderId(providerName: ProviderName, providerUserId: string): ProviderId {
-  return {
-    providerName,
-    providerUserId: normalizeProviderUserId(providerName, providerUserId),
-  }
-}
-
-// PRIVATE API
-export function normalizeProviderUserId(providerName: ProviderName, providerUserId: string): string {
-  switch (providerName) {
-    case 'email':
-    case 'username':
-      return providerUserId.toLowerCase();
-    case 'google':
-    case 'github':
-    case 'discord':
-    case 'keycloak':
-    case 'slack':
-    case 'microsoft':
-      return providerUserId;
-    /*
-      Why the default case?
-      In case users add a new auth provider in the user-land.
-      Users can't extend this function because it is private.
-      If there is an unknown `providerName` in runtime, we'll
-      return the `providerUserId` as is.
-
-      We want to still have explicit OAuth providers listed
-      so that we get a type error if we forget to add a new provider
-      to the switch statement.
-    */
-    default:
-      providerName satisfies never;
-      return providerUserId;
-  }
+  failureRedirectPath: {=& failureRedirectPath =},
+  successRedirectPath: {=& successRedirectPath =},
 }
 
 // PUBLIC API
@@ -129,7 +59,7 @@ export async function findAuthIdentity(providerId: ProviderId): Promise<{= authI
 // PUBLIC API
 /**
  * Updates the provider data for the given auth identity.
- * 
+ *
  * This function performs data sanitization and serialization.
  * Sanitization is done by hashing the password, so this function
  * expects the password received in the `providerDataUpdates`
@@ -221,19 +151,6 @@ export async function deleteUserByAuthId(authId: string): Promise<{ count: numbe
   } } })
 }
 
-// PRIVATE API
-// If an user exists, we don't want to leak information
-// about it. Pretending that we're doing some work
-// will make it harder for an attacker to determine
-// if a user exists or not.
-// NOTE: Attacker measuring time to response can still determine
-// if a user exists or not. We'll be able to avoid it when 
-// we implement e-mail sending via jobs.
-export async function doFakeWork(): Promise<unknown> {
-  const timeToWork = Math.floor(Math.random() * 1000) + 1000;
-  return sleep(timeToWork);
-}
-
 // PRIVATE API
 export function rethrowPossibleAuthError(e: unknown): void {
   // Prisma code P2002 is for unique constraint violations.
@@ -278,6 +195,10 @@ export function rethrowPossibleAuthError(e: unknown): void {
   throw e
 }
 
+function serializeProviderData<PN extends ProviderName>(providerData: PossibleProviderData[PN]): string {
+  return JSON.stringify(providerData);
+}
+
 // PRIVATE API
 export async function validateAndGetUserFields(
   data: {
@@ -299,73 +220,9 @@ export async function validateAndGetUserFields(
     try {
       const value = await getFieldValue(sanitizedData)
       result[field] = value
-    } catch (e) {
-      throwValidationError(e.message)
+    } catch (e: unknown) {
+      throwValidationError(getErrorMessage(e));
     }
   }
   return result;
 }
-
-// PUBLIC API
-export function getProviderData<PN extends ProviderName>(
-  providerData: string,
-):  Omit<PossibleProviderData[PN], 'hashedPassword'> {
-  return sanitizeProviderData(getProviderDataWithPassword(providerData));
-}
-
-// PUBLIC API
-export function getProviderDataWithPassword<PN extends ProviderName>(
-  providerData: string,
-): PossibleProviderData[PN] {
-  // NOTE: We are letting JSON.parse throw an error if the providerData is not valid JSON.
-  return JSON.parse(providerData);
-}
-
-function sanitizeProviderData<PN extends ProviderName>(
-  providerData: PossibleProviderData[PN],
-): Omit<PossibleProviderData[PN], 'hashedPassword'> {
-  if (providerDataHasPasswordField(providerData)) {
-    const { hashedPassword, ...rest } = providerData;
-    return rest;
-  } else {
-    return providerData;
-  }
-}
-
-// PUBLIC API
-export async function sanitizeAndSerializeProviderData<PN extends ProviderName>(
-  providerData: PossibleProviderData[PN],
-): Promise<string> {
-  return serializeProviderData(
-    await ensurePasswordIsHashed(providerData)
-  );
-}
-
-function serializeProviderData<PN extends ProviderName>(providerData: PossibleProviderData[PN]): string {
-  return JSON.stringify(providerData);
-}
-
-async function ensurePasswordIsHashed<PN extends ProviderName>(
-  providerData: PossibleProviderData[PN],
-): Promise<PossibleProviderData[PN]> {
-  const data = {
-    ...providerData,
-  };
-  if (providerDataHasPasswordField(data)) {
-    data.hashedPassword = await hashPassword(data.hashedPassword);
-  }
-
-  return data;
-}
-
-
-function providerDataHasPasswordField(
-  providerData: PossibleProviderData[keyof PossibleProviderData],
-): providerData is { hashedPassword: string } {
-  return 'hashedPassword' in providerData;
-}
-
-// PRIVATE API
-export function createInvalidCredentialsError(message?: string): HttpError {
-  return new HttpError(401, 'Invalid credentials', { message })
-}

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

@@ -1,6 +1,6 @@
 {{={= =}=}}
 import { env } from './env.js'
-import { stripTrailingSlash, getOrigin } from '../universal/url.js'
+import { getOrigin, stripTrailingSlash } from '@wasp.sh/lib-sdk-core'
 
 type NodeEnv = typeof env.NODE_ENV
 

package/data/Generator/templates/sdk/wasp/{core → server/core}/auth.ts

@@ -1,6 +1,6 @@
 import { getSessionAndUserFromBearerToken } from '../auth/session.js'
-import { createInvalidCredentialsError } from '../auth/utils.js'
-import { defineHandler } from '../server/utils.js'
+import { createInvalidCredentialsError } from '@wasp.sh/lib-sdk-core/node'
+import { defineHandler } from '../utils.js'
 
 /**
  * Auth middleware
@@ -14,7 +14,7 @@ import { defineHandler } from '../server/utils.js'
  *   - `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 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

package/data/Generator/templates/sdk/wasp/server/crud/_operationTypes.ts

@@ -11,25 +11,11 @@ import type {
   _{= crud.entityUpper =},
 } from "../_types";
 import type { Prisma } from "@prisma/client";
-import type { Payload, SuperJSONObject } from "../../core/serialization/index.js";
+import type { Payload, SuperJSONObject } from "../../core/serialization/index";
 import type {
   {= crud.entityUpper =},
-} from "../../entities/index.js";
-{=# overrides.GetAll.isDefined =}
-{=& overrides.GetAll.importStatement =}
-{=/ overrides.GetAll.isDefined =}
-{=# overrides.Get.isDefined =}
-{=& overrides.Get.importStatement =}
-{=/ overrides.Get.isDefined =}
-{=# overrides.Create.isDefined =}
-{=& overrides.Create.importStatement =}
-{=/ overrides.Create.isDefined =}
-{=# overrides.Update.isDefined =}
-{=& overrides.Update.importStatement =}
-{=/ overrides.Update.isDefined =}
-{=# overrides.Delete.isDefined =}
-{=& overrides.Delete.importStatement =}
-{=/ overrides.Delete.isDefined =}
+} from "wasp/entities";
+import type { FromRegisterPath } from '../../types/register'
 
 type _WaspEntityTagged = _{= crud.entityUpper =}
 type _WaspEntity = {= crud.entityUpper =}
@@ -41,71 +27,49 @@ export declare namespace {= crud.name =} {
   {=# crud.operations.GetAll =}
   export type GetAllQuery<Input extends Payload = never, Output extends Payload = Payload> = {= queryType =}<[_WaspEntityTagged], Input, Output>
   {=/ crud.operations.GetAll =}
-
   {=# crud.operations.Get =}
+
   export type GetQuery<Input extends Payload = never, Output extends Payload = Payload> = {= queryType =}<[_WaspEntityTagged], Input, Output>
   {=/ crud.operations.Get =}
-
   {=# crud.operations.Create =}
+
   export type CreateAction<Input extends Payload = never, Output extends Payload = Payload> = {= actionType =}<[_WaspEntityTagged], Input, Output>
   {=/ crud.operations.Create =}
-
   {=# crud.operations.Update =}
+
   export type UpdateAction<Input extends Payload = never, Output extends Payload = Payload> = {= actionType =}<[_WaspEntityTagged], Input, Output>
   {=/ crud.operations.Update =}
-
   {=# crud.operations.Delete =}
+
   export type DeleteAction<Input extends Payload = never, Output extends Payload = Payload> = {= actionType =}<[_WaspEntityTagged], Input, Output>
   {=/ crud.operations.Delete =}
 }
 
 /**
  * PRIVATE API
- *
- * The types with the `Resolved` suffix are the types that are used internally by the Wasp client
- * to implement full-stack type safety.
  */
 {=# crud.operations.GetAll =}
-{=^ overrides.GetAll.isDefined =}
 type GetAllInput = {}
 type GetAllOutput = _WaspEntity[]
-export type GetAllQueryResolved = {= crud.name =}.GetAllQuery<GetAllInput, GetAllOutput>
-{=/ overrides.GetAll.isDefined =}
-{=# overrides.GetAll.isDefined =}
-const _waspGetAllQuery = {= overrides.GetAll.importIdentifier =}
-export type GetAllQueryResolved = typeof _waspGetAllQuery
-{=/ overrides.GetAll.isDefined =}
+export type RegisteredGetAllQuery = FromRegisterPath<['crudOverrides', '{= crud.name =}', 'GetAll'], {= crud.name =}.GetAllQuery<GetAllInput, GetAllOutput>>
 {=/ crud.operations.GetAll =}
-
 {=# crud.operations.Get =}
-{=^ overrides.Get.isDefined =}
+
 type GetInput = SuperJSONObject & Prisma.{= crud.entityUpper =}WhereUniqueInput
 type GetOutput = _WaspEntity | null
-export type GetQueryResolved = {= crud.name =}.GetQuery<GetInput, GetOutput>
-{=/ overrides.Get.isDefined =}
-{=# overrides.Get.isDefined =}
-const _waspGetQuery = {= overrides.Get.importIdentifier =}
-export type GetQueryResolved = typeof _waspGetQuery
-{=/ overrides.Get.isDefined =}
+export type RegisteredGetQuery = FromRegisterPath<['crudOverrides', '{= crud.name =}', 'Get'], {= crud.name =}.GetQuery<GetInput, GetOutput>>
 {=/ crud.operations.Get =}
-
 {=# crud.operations.Create =}
-{=^ overrides.Create.isDefined =}
+
 type CreateInput = SuperJSONObject & Prisma.XOR<
   Prisma.{= crud.entityUpper =}CreateInput,
   Prisma.{= crud.entityUpper =}UncheckedCreateInput
 >
 type CreateOutput = _WaspEntity
-export type CreateActionResolved = {= crud.name =}.CreateAction<CreateInput, CreateOutput>
-{=/ overrides.Create.isDefined =}
-{=# overrides.Create.isDefined =}
-const _waspCreateAction = {= overrides.Create.importIdentifier =}
-export type CreateActionResolved = typeof _waspCreateAction
-{=/ overrides.Create.isDefined =}
+export type RegisteredCreateAction = FromRegisterPath<['crudOverrides', '{= crud.name =}', 'Create'], {= crud.name =}.CreateAction<CreateInput, CreateOutput>>
 {=/ crud.operations.Create =}
-
 {=# crud.operations.Update =}
-{=^ overrides.Update.isDefined =}
+
 type UpdateInput = SuperJSONObject & Prisma.XOR<
     Prisma.{= crud.entityUpper =}UpdateInput,
     Prisma.{= crud.entityUpper =}UncheckedUpdateInput
@@ -113,22 +77,11 @@ type UpdateInput = SuperJSONObject & Prisma.XOR<
   & Prisma.{= crud.entityUpper =}WhereUniqueInput
 
 type UpdateOutput = _WaspEntity
-export type UpdateActionResolved = {= crud.name =}.UpdateAction<UpdateInput, UpdateOutput>
-{=/ overrides.Update.isDefined =}
-{=# overrides.Update.isDefined =}
-const _waspUpdateAction = {= overrides.Update.importIdentifier =}
-export type UpdateActionResolved = typeof _waspUpdateAction
-{=/ overrides.Update.isDefined =}
+export type RegisteredUpdateAction = FromRegisterPath<['crudOverrides', '{= crud.name =}', 'Update'], {= crud.name =}.UpdateAction<UpdateInput, UpdateOutput>>
 {=/ crud.operations.Update =}
-
 {=# crud.operations.Delete =}
-{=^ overrides.Delete.isDefined =}
+
 type DeleteInput = SuperJSONObject & Prisma.{= crud.entityUpper =}WhereUniqueInput
 type DeleteOutput = _WaspEntity
-export type DeleteActionResolved = {= crud.name =}.DeleteAction<DeleteInput, DeleteOutput>
-{=/ overrides.Delete.isDefined =}
-{=# overrides.Delete.isDefined =}
-const _waspDeleteAction = {= overrides.Delete.importIdentifier =}
-export type DeleteActionResolved = typeof _waspDeleteAction
-{=/ overrides.Delete.isDefined =}
+export type RegisteredDeleteAction = FromRegisterPath<['crudOverrides', '{= crud.name =}', 'Delete'], {= crud.name =}.DeleteAction<DeleteInput, DeleteOutput>>
 {=/ crud.operations.Delete =}

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

@@ -1,35 +1,33 @@
 {{={= =}=}}
 {=# areThereAnyEntitiesDefined =}
+import { PrismaClient as InternalPrismaClient } from '@prisma/client'
+import type { FromRegister } from '../types/register'
 {=# prismaSetupFn.isDefined =}
 {=& prismaSetupFn.importStatement =}
+{=/ prismaSetupFn.isDefined =}
+
+// PUBLIC API
+export type PrismaClient = ReturnType<RegisteredPrismaSetupFn>;
+
+export type RegisteredPrismaSetupFn = FromRegister<'prismaSetupFn', () => InternalPrismaClient>;
 
-function createDbClient() {
-  return {= prismaSetupFn.importIdentifier =}()
-}
+{=# prismaSetupFn.isDefined =}
+const dbClient: PrismaClient =  {= prismaSetupFn.importIdentifier =}();
 {=/ prismaSetupFn.isDefined =}
 {=^ prismaSetupFn.isDefined =}
-import { PrismaClient as InternalPrismaClient } from '@prisma/client'
-
-function createDbClient() {
-  return new InternalPrismaClient()
-}
+const dbClient: PrismaClient = new InternalPrismaClient();
 {=/ prismaSetupFn.isDefined =}
 {=/ areThereAnyEntitiesDefined =}
 {=^ areThereAnyEntitiesDefined =}
+export type PrismaClient = null;
+
 // * Prisma will not generate a PrismaClient if there no
 //   entities in the schema. Trying to init the PrismaClient
 //   will throw an error.
 // * To avoid throwing an error, we return null if there are no
 //   entities in the schema.
-function createDbClient(): null {
-  return null
-}
+const dbClient: PrismaClient = null;
 {=/ areThereAnyEntitiesDefined =}
 
-const dbClient = createDbClient()
-
-// PUBLIC API 
-export type PrismaClient = typeof dbClient
-
 // PUBLIC API
-export default dbClient
+export default dbClient;

package/data/Generator/templates/sdk/wasp/server/email/core/helpers.ts

@@ -1,30 +1,13 @@
 {{={= =}=}}
-import { EmailFromField } from "./types";
-
-// PRIVATE API
-// Formats an email address and an optional name into a string that can be used
-// as the "from" field in an email.
-// { email: "test@test.com, name: "Test" } -> "Test <test@test.com>"
-export function formatFromField({
-  email,
-  name,
-}: {
-  email: string;
-  name?: string;
-}): string {
-  if (name) {
-    return `${name} <${email}>`;
-  }
-  return email;
-}
+import type { EmailFromField } from '@wasp.sh/lib-sdk-core/node'
 
 {=# isDefaultFromFieldDefined =}
 // PRIVATE API
 export function getDefaultFromField(): EmailFromField {
   return {
-    email: "{= defaultFromField.email =}",
+    email: {=& defaultFromField.email =},
     {=# defaultFromField.isNameDefined =}
-    name: "{= defaultFromField.name =}",
+    name: {=& defaultFromField.name =},
     {=/ defaultFromField.isNameDefined =}
   }
 }

package/data/Generator/templates/sdk/wasp/server/email/core/providers/dummy.ts

@@ -1,7 +1,7 @@
 import { getDefaultFromField } from "../helpers.js";
-import { DummyEmailProvider, EmailSender } from "../types";
+import type { DummyEmailProvider, EmailSender } from "../types";
 
-import { colorize } from "../../../../universal/ansiColors.js";
+import { colorize } from "@wasp.sh/lib-sdk-core";
 
 // PRIVATE API
 export function initDummyEmailSender(

package/data/Generator/templates/sdk/wasp/server/email/core/providers/resend.ts

@@ -1,5 +1,6 @@
 import { Resend } from 'resend';
-import { formatFromField, getDefaultFromField } from "../helpers.js";
+import { formatFromField } from '@wasp.sh/lib-sdk-core/node'
+import { getDefaultFromField } from "../helpers.js";
 import type { ResendEmailProvider, EmailSender } from "../types";
 
 // PRIVATE API

package/data/Generator/templates/sdk/wasp/server/email/core/providers/smtp.ts

@@ -1,5 +1,6 @@
 import { createTransport } from "nodemailer";
-import { formatFromField, getDefaultFromField } from "../helpers.js";
+import { formatFromField } from '@wasp.sh/lib-sdk-core/node'
+import { getDefaultFromField } from "../helpers.js";
 import type { SMTPEmailProvider, EmailSender } from "../types";
 
 // PRIVATE API

package/data/Generator/templates/sdk/wasp/server/email/core/types.ts

@@ -1,49 +1,12 @@
 {{={= =}=}}
-// PRIVATE API
-export type EmailProvider = SMTPEmailProvider | SendGridProvider | MailgunEmailProvider | ResendEmailProvider | DummyEmailProvider;
-
-// PRIVATE API
-export type SMTPEmailProvider = {
-  type: "smtp";
-  host: string;
-  port: number;
-  username: string;
-  password: string;
-};
-
-// PRIVATE API
-export type SendGridProvider = {
-  type: "sendgrid";
-  apiKey: string;
-};
-
-// PRIVATE API
-export type MailgunEmailProvider = {
-  type: "mailgun";
-  apiKey: string;
-  domain: string;
-  apiUrl?: string;
-};
-
-// PRIVATE API
-export type ResendEmailProvider = {
-  type: "resend";
-  apiKey: string;
-};
-
-// PRIVATE API
-export type DummyEmailProvider = {
-  type: "dummy";
-}
+import type { SentMessageInfo, EmailFromField } from '@wasp.sh/lib-sdk-core/node'
+export { type EmailProvider, type SMTPEmailProvider, type SendGridProvider, type MailgunEmailProvider, type ResendEmailProvider, type DummyEmailProvider, type SentMessageInfo, type EmailFromField } from '@wasp.sh/lib-sdk-core/node'
 
 // PUBLIC API
 export type EmailSender = {
   send: (email: Email) => Promise<SentMessageInfo>;
 };
 
-// PUBLIC API
-export type SentMessageInfo = any;
-
 // PUBLIC API
 export type Email = {
   {=# isDefaultFromFieldDefined =}
@@ -57,9 +20,3 @@ export type Email = {
   text: string;
   html: string;
 };
-
-// PUBLIC API
-export type EmailFromField = {
-  name?: string;
-  email: string;
-}

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

@@ -1,7 +1,7 @@
 {{={= =}=}}
 import { env } from '../env.js';
 import { initEmailSender } from "./core/index.js";
-import { EmailSender } from "./core/types.js";
+import type { EmailSender } from "./core/types.js";
 
 {=# isSmtpProviderEnabled =}
 const emailProvider = { 

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

@@ -1,17 +1,25 @@
 {{={= =}=}}
 import * as z from "zod"
-
-import { ensureEnvSchema } from "../env/validation.js"
+import { ensureEnvSchema } from "@wasp.sh/lib-sdk-core"
+import type { FromRegister } from "../types/register";
 {=# envValidationSchema.isDefined =}
 {=& envValidationSchema.importStatement =}
-const userServerEnvSchema = {= envValidationSchema.importIdentifier =};
+{=/ envValidationSchema.isDefined =}
+
+export type RegisteredServerEnvValidationSchema = FromRegister<"serverEnvValidationSchema", z.ZodObject<{}>>;
+type UserServerEnvSchema = RegisteredServerEnvValidationSchema;
+
+{=# envValidationSchema.isDefined =}
+const userServerEnvSchema: UserServerEnvSchema = {= envValidationSchema.importIdentifier =};
 {=/ envValidationSchema.isDefined =}
 {=^ envValidationSchema.isDefined =}
-const userServerEnvSchema = z.object({});
+const userServerEnvSchema: UserServerEnvSchema = z.object({});
 {=/ envValidationSchema.isDefined =}
 
 const waspCommonServerEnvSchema = z.object({
-  PORT: z.coerce.number().default({= defaultServerPort =}),
+  {= serverPortEnvVarName =}: z.coerce.number({
+    error: '{= serverPortEnvVarName =} is required and must be a number',
+  }),
   {= databaseUrlEnvVarName =}: z.string({
     error: '{= databaseUrlEnvVarName =} is required',
   }),
@@ -152,10 +160,8 @@ const jwtTokenSchema = z
 // to make the development process easier.
 const waspDevServerEnvSchema = z.object({
   NODE_ENV: z.literal("development"),
-  "{= serverUrlEnvVarName =}": serverUrlSchema
-    .default("{= defaultServerUrl =}"),
-  "{= clientUrlEnvVarName =}": clientUrlSchema
-    .default("{= defaultClientUrl =}"),
+  "{= serverUrlEnvVarName =}": serverUrlSchema,
+  "{= clientUrlEnvVarName =}": clientUrlSchema,
   {=# isAuthEnabled =}
   "{= jwtSecretEnvVarName =}": jwtTokenSchema
     .default("DEVJWTSECRET"),
@@ -175,13 +181,16 @@ const waspServerEnvSchema = z.discriminatedUnion("NODE_ENV", [
   z.object({...waspCommonServerEnvSchema.shape, ...waspDevServerEnvSchema.shape}),
   z.object({...waspCommonServerEnvSchema.shape, ...waspProdServerEnvSchema.shape}),
 ]);
-const serverEnvSchema = userServerEnvSchema.and(waspServerEnvSchema);
+
+type CompleteServerEnvSchema = z.ZodIntersection<UserServerEnvSchema, typeof waspServerEnvSchema>;
+
+const serverEnvSchema: CompleteServerEnvSchema = userServerEnvSchema.and(waspServerEnvSchema);
 
 const defaultNodeEnvValue = waspDevServerEnvSchema.shape.NODE_ENV.value;
 const { NODE_ENV: inputNodeEnvValue, ...restEnv } = process.env;
 
 // PUBLIC API
-export const env = ensureEnvSchema(
+export const env: z.infer<CompleteServerEnvSchema> = ensureEnvSchema(
   {
     NODE_ENV: inputNodeEnvValue ?? defaultNodeEnvValue,
     ...restEnv,