@wasp.sh/wasp-cli-darwin-arm64-unknown 0.17.2

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

@@ -0,0 +1,39 @@
+{{={= =}=}}
+import { env } from '../env.js';
+import { initEmailSender } from "./core/index.js";
+import { EmailSender } from "./core/types.js";
+
+{=# isSmtpProviderEnabled =}
+const emailProvider = { 
+    type: "smtp",
+    host: env.SMTP_HOST,
+    port: env.SMTP_PORT,
+    username: env.SMTP_USERNAME,
+    password: env.SMTP_PASSWORD,
+} as const;
+{=/ isSmtpProviderEnabled =}
+{=# isSendGridProviderEnabled =}
+const emailProvider = {
+  type: "sendgrid",
+  apiKey: env.SENDGRID_API_KEY,
+} as const;
+{=/ isSendGridProviderEnabled =}
+{=# isMailgunProviderEnabled =}
+const emailProvider = {
+  type: "mailgun",
+  apiKey: env.MAILGUN_API_KEY,
+  domain: env.MAILGUN_DOMAIN,
+  apiUrl: env.MAILGUN_API_URL,
+} as const;
+{=/ isMailgunProviderEnabled =}
+{=# isDummyProviderEnabled =}
+const emailProvider = {
+  type: "dummy",
+} as const;
+{=/ isDummyProviderEnabled =}
+
+// PUBLIC API
+export const emailSender: EmailSender = initEmailSender(emailProvider);
+
+// PUBLIC API
+export type { Email, EmailFromField, EmailSender, SentMessageInfo } from "./core/types.js";

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

@@ -0,0 +1,168 @@
+{{={= =}=}}
+import * as z from 'zod'
+
+import { ensureEnvSchema } from '../env/validation.js'
+
+{=# envValidationSchema.isDefined =}
+{=& envValidationSchema.importStatement =}
+const userServerEnvSchema = {= envValidationSchema.importIdentifier =}
+{=/ envValidationSchema.isDefined =}
+{=^ envValidationSchema.isDefined =}
+const userServerEnvSchema = z.object({})
+{=/ envValidationSchema.isDefined =}
+
+const waspServerCommonSchema = z.object({
+  PORT: z.coerce.number().default({= defaultServerPort =}),
+  {= databaseUrlEnvVarName =}: z.string({
+    required_error: '{= databaseUrlEnvVarName =} is required',
+  }),
+  PG_BOSS_NEW_OPTIONS: z.string().optional(),
+  {=# isEmailSenderEnabled =}
+  {=# enabledEmailSenders.isSmtpProviderEnabled =}
+  SMTP_HOST: z.string({
+    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_HOST'),
+  }),
+  SMTP_PORT: z.coerce.number({
+    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_PORT'),
+    invalid_type_error: 'SMTP_PORT must be a number',
+  }),
+  SMTP_USERNAME: z.string({
+    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_USERNAME'),
+  }),
+  SMTP_PASSWORD: z.string({
+    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_PASSWORD'),
+  }),
+  {=/ enabledEmailSenders.isSmtpProviderEnabled =}
+  {=# enabledEmailSenders.isSendGridProviderEnabled =}
+  SENDGRID_API_KEY: z.string({
+    required_error: getRequiredEnvVarErrorMessage('SendGrid email sender', 'SENDGRID_API_KEY'),
+  }),
+  {=/ enabledEmailSenders.isSendGridProviderEnabled =}
+  {=# enabledEmailSenders.isMailgunProviderEnabled =}
+  MAILGUN_API_KEY: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Mailgun email sender', 'MAILGUN_API_KEY'),
+  }),
+  MAILGUN_DOMAIN: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Mailgun email sender', 'MAILGUN_DOMAIN'),
+  }),
+  MAILGUN_API_URL: z.string().optional(),
+  {=/ enabledEmailSenders.isMailgunProviderEnabled =}
+  {=/ isEmailSenderEnabled =}
+  SKIP_EMAIL_VERIFICATION_IN_DEV: z
+    .enum(['true', 'false'], {
+      message: 'SKIP_EMAIL_VERIFICATION_IN_DEV must be either "true" or "false"',
+    })
+    .transform((value) => value === 'true')
+    .default('false'),
+  {=# isAuthEnabled =}
+  {=# enabledAuthProviders.isGoogleAuthEnabled =}
+  GOOGLE_CLIENT_ID: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Google auth provider', 'GOOGLE_CLIENT_ID'),
+  }),
+  GOOGLE_CLIENT_SECRET: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Google auth provider', 'GOOGLE_CLIENT_SECRET'),
+  }),
+  {=/ enabledAuthProviders.isGoogleAuthEnabled =}
+  {=# enabledAuthProviders.isGitHubAuthEnabled =}
+  GITHUB_CLIENT_ID: z.string({
+    required_error: getRequiredEnvVarErrorMessage('GitHub auth provider', 'GITHUB_CLIENT_ID'),
+  }),
+  GITHUB_CLIENT_SECRET: z.string({
+    required_error: getRequiredEnvVarErrorMessage('GitHub auth provider', 'GITHUB_CLIENT_SECRET'),
+  }),
+  {=/ enabledAuthProviders.isGitHubAuthEnabled =}
+  {=# enabledAuthProviders.isSlackAuthEnabled =}
+  SLACK_CLIENT_ID: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Slack auth provider', 'SLACK_CLIENT_ID'),
+  }),
+  SLACK_CLIENT_SECRET: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Slack auth provider', 'SLACK_CLIENT_SECRET'),
+  }),
+  {=/ enabledAuthProviders.isSlackAuthEnabled =}
+  {=# enabledAuthProviders.isDiscordAuthEnabled =}
+  DISCORD_CLIENT_ID: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Discord auth provider', 'DISCORD_CLIENT_ID'),
+  }),
+  DISCORD_CLIENT_SECRET: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Discord auth provider', 'DISCORD_CLIENT_SECRET'),
+  }),
+  {=/ enabledAuthProviders.isDiscordAuthEnabled =}
+  {=# enabledAuthProviders.isKeycloakAuthEnabled =}
+  KEYCLOAK_CLIENT_ID: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_CLIENT_ID'),
+  }),
+  KEYCLOAK_CLIENT_SECRET: z.string({
+    required_error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_CLIENT_SECRET'),
+  }),
+  KEYCLOAK_REALM_URL: z
+    .string({
+      required_error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_REALM_URL'),
+    })
+    .url({
+      message: 'KEYCLOAK_REALM_URL must be a valid URL',
+    }),
+  {=/ enabledAuthProviders.isKeycloakAuthEnabled =}
+  {=/ isAuthEnabled =}
+})
+
+const serverUrlSchema = z
+  .string({
+    required_error: 'WASP_SERVER_URL is required',
+  })
+  .url({
+    message: 'WASP_SERVER_URL must be a valid URL',
+  })
+
+const clientUrlSchema = z
+  .string({
+    required_error: 'WASP_WEB_CLIENT_URL is required',
+  })
+  .url({
+    message: 'WASP_WEB_CLIENT_URL must be a valid URL',
+  })
+
+{=# isAuthEnabled =}
+const jwtTokenSchema = z
+  .string({
+    required_error: 'JWT_SECRET is required',
+  })
+{=/ isAuthEnabled =}
+
+// In development, we provide default values for some environment variables
+// to make the development process easier.
+const serverDevSchema = z.object({
+  NODE_ENV: z.literal('development'),
+  WASP_SERVER_URL: serverUrlSchema
+    .default('{= defaultServerUrl =}'),
+  WASP_WEB_CLIENT_URL: clientUrlSchema
+    .default('{= defaultClientUrl =}'),
+  {=# isAuthEnabled =}
+  JWT_SECRET: jwtTokenSchema
+    .default('DEVJWTSECRET'),
+  {=/ isAuthEnabled =}
+})
+
+const serverProdSchema = z.object({
+  NODE_ENV: z.literal('production'),
+  WASP_SERVER_URL: serverUrlSchema,
+  WASP_WEB_CLIENT_URL: clientUrlSchema,
+  {=# isAuthEnabled =}
+  JWT_SECRET: jwtTokenSchema,
+  {=/ isAuthEnabled =}
+})
+
+const serverCommonSchema = userServerEnvSchema.merge(waspServerCommonSchema)
+const serverEnvSchema = z.discriminatedUnion('NODE_ENV', [
+  serverDevSchema.merge(serverCommonSchema),
+  serverProdSchema.merge(serverCommonSchema)
+])
+
+// PUBLIC API
+export const env = ensureEnvSchema(
+  { NODE_ENV: serverDevSchema.shape.NODE_ENV.value, ...process.env },
+  serverEnvSchema,
+)
+
+function getRequiredEnvVarErrorMessage(featureName: string, envVarName: string) {
+  return `${envVarName} is required when using ${featureName}`
+}

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

@@ -0,0 +1,17 @@
+import type { PrismaClient } from './dbClient.js'
+
+// PUBLIC API
+export { default as config } from './config.js'
+// PUBLIC API
+export { default as prisma, type PrismaClient } from './dbClient.js'
+// PUBLIC API
+export { type ServerSetupFn } from './types/index.js'
+// PUBLIC API
+export { HttpError } from './HttpError.js'
+// PUBLIC API
+export { MiddlewareConfigFn } from './middleware/index.js'
+// PUBLIC API
+export { env } from './env.js'
+
+// PUBLIC API
+export type DbSeedFn = (prisma: PrismaClient) => Promise<void>

package/data/Generator/templates/sdk/wasp/server/jobs/_job.ts

@@ -0,0 +1,39 @@
+{{={= =}=}}
+import { prisma } from 'wasp/server'
+import type { JSONValue, JSONObject } from 'wasp/core/serialization'
+import { type JobFn, createJobDefinition } from '{= jobExecutorImportPath =}'
+
+const entities = {
+  {=# entities =}
+  {= name =}: prisma.{= prismaIdentifier =},
+  {=/ entities =}
+}
+
+// PUBLIC API
+export type {= typeName =}<Input extends JSONObject, Output extends JSONValue | void> = JobFn<Input, Output, typeof entities>
+
+{=# jobSchedule.isDefined =}
+const jobSchedule = {
+  cron: "{= jobSchedule.cron =}",
+  {=# jobSchedule.args.isDefined =}
+  args: {=& jobSchedule.args.json =},
+  {=/ jobSchedule.args.isDefined =}
+  {=# jobSchedule.options.isDefined =}
+  options: {=& jobSchedule.options.json =},
+  {=/ jobSchedule.options.isDefined =}
+  {=^ jobSchedule.options.isDefined =}
+  options: {},
+  {=/ jobSchedule.options.isDefined =}
+}
+{=/ jobSchedule.isDefined =}
+{=^ jobSchedule.isDefined =}
+const jobSchedule = null
+{=/ jobSchedule.isDefined =}
+
+// PUBLIC API
+export const {= jobName =} = createJobDefinition({
+  jobName: '{= jobName =}',
+  defaultJobOptions: {=& jobPerformOptions =},
+  jobSchedule,
+  entities,
+})

package/data/Generator/templates/sdk/wasp/server/jobs/core/job.ts

@@ -0,0 +1,28 @@
+/**
+ * This is a definition of a job (think draft or invocable computation), not the running instance itself.
+ * This can be submitted one or more times to be executed by some job executor via the same instance.
+ * Once submitted, you get a SubmittedJob to track it later.
+ */
+export class Job {
+  public readonly jobName: string
+  public readonly executorName: string | symbol
+
+  constructor(jobName: string, executorName: string | symbol) {
+    this.jobName = jobName
+    this.executorName = executorName
+  }
+}
+
+/**
+ * This is the result of submitting a Job to some executor.
+ * It can be used by callers to track things, or call executor-specific subclass functionality.
+ */
+export class SubmittedJob {
+  public readonly job: Job
+  public readonly jobId: string
+
+  constructor(job: Job, jobId: string) {
+    this.job = job
+    this.jobId = jobId
+  }
+}

package/data/Generator/templates/sdk/wasp/server/jobs/core/pgBoss/index.ts

@@ -0,0 +1,3 @@
+export { type JobFn } from './types'
+export { registerJob, createJobDefinition } from './pgBossJob.js'
+export { startPgBoss } from './pgBoss.js'

package/data/Generator/templates/sdk/wasp/server/jobs/core/pgBoss/pgBoss.ts

@@ -0,0 +1,76 @@
+import PgBoss from 'pg-boss'
+import { config, env } from '../../../index.js'
+
+const boss = createPgBoss()
+
+function createPgBoss() {
+  let pgBossNewOptions = {
+    connectionString: config.databaseUrl,
+  }
+
+  // Add an escape hatch for advanced configuration of pg-boss to overwrite our defaults.
+  if (env.PG_BOSS_NEW_OPTIONS) {
+    try {
+      pgBossNewOptions = JSON.parse(env.PG_BOSS_NEW_OPTIONS)
+    } catch {
+      console.error(
+        'Environment variable PG_BOSS_NEW_OPTIONS was not parsable by JSON.parse()!'
+      )
+    }
+  }
+
+  return new PgBoss(pgBossNewOptions)
+}
+
+let resolvePgBossStarted: (boss: PgBoss) => void
+let rejectPgBossStarted: (boss: PgBoss) => void
+// PRIVATE API
+// Code that wants to access pg-boss must wait until it has been started.
+export const pgBossStarted = new Promise<PgBoss>((resolve, reject) => {
+  resolvePgBossStarted = resolve
+  rejectPgBossStarted = reject
+})
+
+enum PgBossStatus {
+  Unstarted = 'Unstarted',
+  Starting = 'Starting',
+  Started = 'Started',
+  Error = 'Error',
+}
+
+let pgBossStatus: PgBossStatus = PgBossStatus.Unstarted
+
+// PRIVATE API
+/**
+ * Prepares the target PostgreSQL database and begins job monitoring.
+ * If the required database objects do not exist in the specified database,
+ * `boss.start()` will automatically create them.
+ * Ref: https://github.com/timgit/pg-boss/blob/master/docs/readme.md#start
+ *
+ * After making this call, we can send pg-boss jobs and they will be persisted and acted upon.
+ * This should only be called once during a server's lifetime.
+ */
+export async function startPgBoss(): Promise<void> {
+  // Ensure pg-boss can only be started once during a server's lifetime.
+  if (pgBossStatus !== PgBossStatus.Unstarted) {
+    return
+  }
+  pgBossStatus = PgBossStatus.Starting
+  console.log('Starting pg-boss...')
+
+  boss.on('error', (error) => console.error(error))
+  try {
+    await boss.start()
+  } catch (error) {
+    console.error('pg-boss failed to start!')
+    console.error(error)
+    pgBossStatus = PgBossStatus.Error
+    rejectPgBossStarted(boss)
+    return
+  }
+
+  resolvePgBossStarted(boss)
+
+  console.log('pg-boss started!')
+  pgBossStatus = PgBossStatus.Started
+}

package/data/Generator/templates/sdk/wasp/server/jobs/core/pgBoss/pgBossJob.ts

@@ -0,0 +1,230 @@
+import PgBoss from 'pg-boss'
+import { pgBossStarted } from './pgBoss.js'
+import { Job, SubmittedJob } from '../job.js'
+import type { JSONValue, JSONObject } from 'wasp/core/serialization'
+import { PrismaDelegate } from 'wasp/server/_types'
+import type { JobFn } from 'wasp/server/jobs/core/pgBoss'
+
+export const PG_BOSS_EXECUTOR_NAME = Symbol('PgBoss')
+
+type JobSchedule = {
+  cron: Parameters<PgBoss['schedule']>[1]
+  options: Parameters<PgBoss['schedule']>[3]
+  args?: NonNullable<Parameters<PgBoss['schedule']>[2]>
+}
+
+// PRIVATE API
+/**
+ * Creates an instance of PgBossJob which contains all of the necessary
+ * information to submit a job to pg-boss.
+ */
+export function createJobDefinition<
+  Input extends JSONObject,
+  Output extends JSONValue | void,
+  Entities extends Partial<PrismaDelegate>
+>({
+  jobName,
+  defaultJobOptions,
+  jobSchedule,
+  entities,
+}: {
+  // jobName - The user-defined job name in their .wasp file.
+  jobName: PgBossJob<Input, Output, Entities>['jobName']
+  // defaultJobOptions - pg-boss specific options for `boss.send()` applied to every `submit()` invocation,
+  // which can overriden in that call.
+  defaultJobOptions: PgBossJob<Input, Output, Entities>['defaultJobOptions']
+  jobSchedule: PgBossJob<Input, Output, Entities>['jobSchedule']
+  // Entities used by job, passed into callback context.
+  entities: Entities
+}) {
+  return new PgBossJob<Input, Output, Entities>(
+    jobName,
+    defaultJobOptions,
+    entities,
+    jobSchedule,
+  )
+}
+
+// PRIVATE API
+/**
+ * Uses the info about a job in PgBossJob to register a user defined job handler with pg-boss.
+ * We expect this to be called once per job name. If called multiple times with the same name and different
+ * functions, we will override the previous calls.
+ */
+export function registerJob<
+  Input extends JSONObject,
+  Output extends JSONValue | void,
+  Entities extends Partial<PrismaDelegate>
+>({ job, jobFn }: {
+  job: PgBossJob<Input, Output, Entities>,
+  jobFn: JobFn<Input, Output, Entities>,
+}) {
+  // NOTE(shayne): We are not awaiting `pgBossStarted` here since we need to return an instance to the job
+  // template, or else the NodeJS module bootstrapping process will block and fail as it would then depend
+  // on a runtime resolution of the promise in `startServer()`.
+  // Since `pgBossStarted` will resolve in the future, it may appear possible to send pg-boss
+  // a job before we actually have registered the handler via `boss.work()`. However, even if NodeJS does
+  // not execute this callback before any job `submit()` calls, this is not a problem since pg-boss allows you
+  // to submit jobs even if there are no workers registered.
+  // Once they are registered, they will just start on the first job in their queue.
+  pgBossStarted.then(async (boss) => {
+    // As a safety precaution against undefined behavior of registering different
+    // functions for the same job name, remove all registered functions first.
+    await boss.offWork(job.jobName)
+
+    // This tells pg-boss to run given worker function when job with that name is submitted.
+    // Ref: https://github.com/timgit/pg-boss/blob/master/docs/readme.md#work
+    await boss.work<Input, Output>(
+      job.jobName,
+      pgBossCallbackWrapper<Input, Output, Entities>(jobFn, job.entities)
+    )
+
+    // If a job schedule is provided, we should schedule the recurring job.
+    // If the schedule name already exists, it's updated to the provided cron expression, arguments, and options.
+    // Ref: https://github.com/timgit/pg-boss/blob/master/docs/readme.md#scheduling
+    if (job.jobSchedule) {
+      const options: PgBoss.ScheduleOptions = {
+        ...job.defaultJobOptions,
+        ...job.jobSchedule.options,
+      }
+      await boss.schedule(
+        job.jobName,
+        job.jobSchedule.cron,
+        job.jobSchedule.args,
+        options
+      )
+    }
+  })
+}
+
+/**
+ * This is an interface repesenting a job that can be submitted to pg-boss.
+ * It is not yet submitted until the caller invokes `submit()` on an instance.
+ * The caller can make as many calls to `submit()` as they wish.
+ */
+export class PgBossJob<
+  Input extends JSONObject,
+  Output extends JSONValue | void,
+  Entities extends Partial<PrismaDelegate>
+> extends Job {
+  public readonly defaultJobOptions: Parameters<PgBoss['send']>[2]
+  public readonly startAfter: number | string | Date | undefined
+  public readonly entities: Entities
+  public readonly jobSchedule: JobSchedule | null
+
+  constructor(
+    jobName: string,
+    defaultJobOptions: Parameters<PgBoss['send']>[2],
+    entities: Entities,
+    jobSchedule: JobSchedule | null,
+    startAfter?: number | string | Date
+  ) {
+    super(jobName, PG_BOSS_EXECUTOR_NAME)
+    this.defaultJobOptions = defaultJobOptions
+    this.entities = entities
+    this.jobSchedule = jobSchedule
+    this.startAfter = startAfter
+  }
+  delay(startAfter: number | string | Date) {
+    return new PgBossJob<Input, Output, Entities>(
+      this.jobName,
+      this.defaultJobOptions,
+      this.entities,
+      this.jobSchedule,
+      startAfter
+    )
+  }
+  async submit(jobArgs: Input, jobOptions: Parameters<PgBoss['send']>[2] = {}) {
+    const boss = await pgBossStarted
+    const jobId = await (boss.send as any)(this.jobName, jobArgs, {
+      ...this.defaultJobOptions,
+      ...(this.startAfter && { startAfter: this.startAfter }),
+      ...jobOptions,
+    })
+    return new PgBossSubmittedJob<Input, Output, Entities>(boss, this, jobId)
+  }
+}
+
+/**
+ * A pg-boss specific SubmittedJob that adds additional pg-boss functionality.
+ */
+class PgBossSubmittedJob<
+  Input extends JSONObject,
+  Output extends JSONValue | void,
+  Entities extends Partial<PrismaDelegate>
+> extends SubmittedJob {
+  public readonly pgBoss: {
+    readonly cancel: () => ReturnType<PgBoss['cancel']>
+    readonly resume: () => ReturnType<PgBoss['resume']>
+    readonly details: () => Promise<PgBossDetails<Input, Output> | null>
+  }
+
+  constructor(
+    boss: PgBoss,
+    job: PgBossJob<Input, Output, Entities>,
+    jobId: SubmittedJob['jobId']
+  ) {
+    super(job, jobId)
+    this.pgBoss = {
+      cancel: () => boss.cancel(jobId),
+      resume: () => boss.resume(jobId),
+      // Coarcing here since pg-boss typings are not precise enough.
+      details: () =>
+        boss.getJobById(jobId) as Promise<PgBossDetails<Input, Output> | null>,
+    }
+  }
+}
+
+/**
+ * Wraps the normal pg-boss callback function to inject entities, as well as extract
+ * the `data` property so the arguments passed into the job are the exact same as those received.
+ */
+function pgBossCallbackWrapper<
+  Input extends JSONObject,
+  Output extends JSONValue | void,
+  Entities extends Partial<PrismaDelegate>
+>(
+  // jobFn - The user-defined async job callback function.
+  jobFn: JobFn<Input, Output, Entities>,
+  // Entities used by job, passed into callback context.
+  entities: Entities
+) {
+  return (args: { data: Input }) => {
+    const context = { entities }
+    return jobFn(args.data, context)
+  }
+}
+
+// Overrides the default pg-boss JobWithMetadata type to provide more
+// type safety.
+type PgBossDetails<
+  Input extends JSONObject,
+  Output extends JSONValue | void
+> = Omit<PgBoss.JobWithMetadata<Input>, 'state' | 'output'> & {
+  data: Input
+} & (
+    | {
+        state: 'completed'
+        output: JobOutputToMetadataOutput<Output>
+      }
+    | {
+        state: 'failed'
+        output: object
+      }
+    | {
+        state: 'created' | 'retry' | 'active' | 'expired' | 'cancelled'
+        output: null
+      }
+  )
+
+// pg-boss wraps primitive values in an object with a `value` property.
+// https://github.com/timgit/pg-boss/blob/master/src/manager.js#L526
+type JobOutputToMetadataOutput<JobOutput> = JobOutput extends
+  | null
+  | undefined
+  | void
+  | Function
+  ? null
+  : JobOutput extends object
+  ? JobOutput
+  : { value: JobOutput }

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

@@ -0,0 +1,9 @@
+import { PrismaDelegate } from 'wasp/server/_types'
+import type { JSONValue, JSONObject } from 'wasp/core/serialization'
+
+// PRIVATE API
+export type JobFn<
+  Input extends JSONObject,
+  Output extends JSONValue | void,
+  Entities extends Partial<PrismaDelegate>
+> = (data: Input, context: { entities: Entities }) => Promise<Output>

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

@@ -0,0 +1,5 @@
+{{={= =}=}}
+
+{=# jobs =}
+export { type {= typeName =}, {= jobName =} } from './{= jobName =}.js'
+{=/ jobs =}

package/data/Generator/templates/sdk/wasp/server/middleware/globalMiddleware.ts

@@ -0,0 +1,8 @@
+import { type RequestHandler } from 'express'
+
+// PUBLIC API
+export type MiddlewareConfigFn = (middlewareConfig: MiddlewareConfig) => MiddlewareConfig
+
+// PRIVATE API
+export type MiddlewareConfig = Map<string, RequestHandler>
+

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

@@ -0,0 +1 @@
+export * from './globalMiddleware.js'

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

@@ -0,0 +1,41 @@
+{{={= =}=}}
+{=! TODO: This template is exactly the same at the moment as one for queries,
+          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 =}