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

package/data/Generator/templates/server/src/crud/_operations.ts

@@ -0,0 +1,184 @@
+{{={= =}=}}
+import { prisma } from 'wasp/server'
+
+{=# isAuthEnabled =}
+import { createInvalidCredentialsError } from 'wasp/auth/utils'
+{=/ isAuthEnabled =}
+import type {
+  {=# crud.operations.GetAll =}
+  GetAllQueryResolved,
+  {=/ crud.operations.GetAll =}
+  {=# crud.operations.Get =}
+  GetQueryResolved,
+  {=/ crud.operations.Get =}
+  {=# crud.operations.Create =}
+  CreateActionResolved,
+  {=/ crud.operations.Create =}
+  {=# crud.operations.Update =}
+  UpdateActionResolved,
+  {=/ crud.operations.Update =}
+  {=# crud.operations.Delete =}
+  DeleteActionResolved,
+  {=/ crud.operations.Delete =}
+} from 'wasp/server/crud/{= crud.name =}'
+{=# 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 =}
+
+const entities = {
+  {= crud.entityUpper =}: prisma.{= crud.entityLower =},
+}
+
+{=!
+// Let's explain this template on the GetAll operation example
+=}
+{=# crud.operations.GetAll =}
+// Get All query
+{=!
+// 1. We either use the default implementation of the operation...
+=}
+{=^ overrides.GetAll.isDefined =}
+const _waspGetAllQuery: GetAllQueryResolved = ((args, context) => {
+  {=^ crud.operations.GetAll.isPublic =}
+  throwIfNotAuthenticated(context)
+  {=/ crud.operations.GetAll.isPublic =}
+  return context.entities.{= crud.entityUpper =}.findMany();
+});
+{=/ overrides.GetAll.isDefined =}
+{=!
+// ... or the one defined in the overrides by the user. We use the "importIdentifier" property to
+// reference the function from the overrides.
+=}
+{=# overrides.GetAll.isDefined =}
+const _waspGetAllQuery = {= overrides.GetAll.importIdentifier =}
+{=/ overrides.GetAll.isDefined =}
+
+{=!
+// 2. We define a function that is used as the Express route handler
+=}
+export async function getAllFn(args, context) {
+  return (_waspGetAllQuery as any)(args, {
+    ...context,
+    entities,
+  });
+}
+{=/ crud.operations.GetAll =}
+{=!
+// That's it! It is similar for all other operations.
+=}  
+
+{=# crud.operations.Get =}
+// Get query
+{=^ overrides.Get.isDefined =}
+const _waspGetQuery: GetQueryResolved = ((args, context) => {
+  {=^ crud.operations.Get.isPublic =}
+  throwIfNotAuthenticated(context)
+  {=/ crud.operations.Get.isPublic =}
+  return context.entities.{= crud.entityUpper =}.findUnique({ where: { id: args.id } });
+});
+{=/ overrides.Get.isDefined =}
+{=# overrides.Get.isDefined =}
+const _waspGetQuery = {= overrides.Get.importIdentifier =}
+{=/ overrides.Get.isDefined =}
+
+export async function getFn(args, context) {
+  return (_waspGetQuery as any)(args, {
+    ...context,
+    entities,
+  });
+}
+{=/ crud.operations.Get =}
+
+{=# crud.operations.Create =}
+// Create action
+{=^ overrides.Create.isDefined =}
+const _waspCreateAction: CreateActionResolved = ((args, context) => {
+  {=^ crud.operations.Create.isPublic =}
+  throwIfNotAuthenticated(context)
+  {=/ crud.operations.Create.isPublic =}
+  return context.entities.{= crud.entityUpper =}.create({ data: args });
+});
+{=/ overrides.Create.isDefined =}
+{=# overrides.Create.isDefined =}
+const _waspCreateAction = {= overrides.Create.importIdentifier =}
+{=/ overrides.Create.isDefined =}
+
+export async function createFn(args, context) {
+  return (_waspCreateAction as any)(args, {
+    ...context,
+    entities,
+  });
+}
+{=/ crud.operations.Create =}
+
+{=# crud.operations.Update =}
+// Update action
+{=^ overrides.Update.isDefined =}
+const _waspUpdateAction: UpdateActionResolved = ((args, context) => {
+  {=^ crud.operations.Update.isPublic =}
+  throwIfNotAuthenticated(context)
+  {=/ crud.operations.Update.isPublic =}
+  const { {= crud.idFieldName =}: idFieldValue, ...rest } = args
+  return context.entities.{= crud.entityUpper =}.update({
+    where: { {= crud.idFieldName =}: idFieldValue },
+    data: rest,
+  });
+});
+{=/ overrides.Update.isDefined =}
+{=# overrides.Update.isDefined =}
+const _waspUpdateAction = {= overrides.Update.importIdentifier =}
+{=/ overrides.Update.isDefined =}
+
+export async function updateFn(args, context) {
+  return (_waspUpdateAction as any)(args, {
+    ...context,
+    entities,
+  });
+}
+{=/ crud.operations.Update =}
+
+{=# crud.operations.Delete =}
+// Delete action
+{=^ overrides.Delete.isDefined =}
+const _waspDeleteAction: DeleteActionResolved = ((args, context) => {
+  {=^ crud.operations.Delete.isPublic =}
+  throwIfNotAuthenticated(context)
+  {=/ crud.operations.Delete.isPublic =}
+  const { {= crud.idFieldName =}: idFieldValue } = args
+  return context.entities.{= crud.entityUpper =}.delete({ where:  { {= crud.idFieldName =}: idFieldValue } });
+});
+{=/ overrides.Delete.isDefined =}
+{=# overrides.Delete.isDefined =}
+const _waspDeleteAction = {= overrides.Delete.importIdentifier =}
+{=/ overrides.Delete.isDefined =}
+
+export async function deleteFn(args, context) {
+  return (_waspDeleteAction as any)(args, {
+    ...context,
+    entities,
+  });
+}
+{=/ crud.operations.Delete =}
+
+function throwIfNotAuthenticated (context) {
+  {=# isAuthEnabled =}
+  if (!context.user) {
+    throw createInvalidCredentialsError()
+  }
+  {=/ isAuthEnabled =}
+  {=^ isAuthEnabled =}
+  // Auth is not enabled
+  {=/ isAuthEnabled =}
+}

package/data/Generator/templates/server/src/dbSeed.ts

@@ -0,0 +1,37 @@
+{{={= =}=}}
+
+// This is a script that is used to seed the database. It is present here in the server project in
+// order to have easy access to the server logic, like operations and the rest, since we often want
+// to use that logic in our seeding.
+// TODO: Consider in the future moving it into a a separate project (maybe db/ ?), while still
+//   maintaining access to logic from the server/ .
+
+import { prisma, DbSeedFn } from 'wasp/server'
+
+{=# dbSeeds =}
+{=& importStatement =}
+{=/ dbSeeds =}
+
+const seeds = {
+  {=# dbSeeds =}
+  {= importIdentifier =},
+  {=/ dbSeeds =}
+}
+
+async function main() {
+  const nameOfSeedToRun = process.env.{= dbSeedNameEnvVarName =}
+  if (nameOfSeedToRun) {
+    console.log(`Running seed: ${nameOfSeedToRun}`)
+  } else {
+    console.error('Name of the seed to run not specified!')
+  }
+  await (seeds[nameOfSeedToRun] satisfies DbSeedFn)(prisma)
+}
+
+main()
+  .then(async () => { await prisma.$disconnect() })
+  .catch(async (e) => {
+    console.error(e)
+    await prisma.$disconnect()
+    process.exit(1)
+  })

package/data/Generator/templates/server/src/jobs/_job.ts

@@ -0,0 +1,9 @@
+{{={= =}=}}
+import { registerJob } from '{= jobExecutorImportPath =}'
+{=& jobPerformFn.importStatement =}
+{=& jobDefinition.importStatement =}
+
+registerJob({
+  job: {= jobDefinition.importIdentifier =},
+  jobFn: {= jobPerformFn.importIdentifier =},
+})

package/data/Generator/templates/server/src/jobs/core/allJobs.ts

@@ -0,0 +1,8 @@
+{{={= =}=}}
+
+// This module imports all jobs and is imported by the server to ensure
+// any schedules that are not referenced are still loaded by NodeJS.
+
+{=# jobs =}
+import '../{= name =}.js'
+{=/ jobs =}

package/data/Generator/templates/server/src/middleware/globalMiddleware.ts

@@ -0,0 +1,45 @@
+{{={= =}=}}
+import express from 'express'
+import cookieParser from 'cookie-parser'
+import logger from 'morgan'
+import cors from 'cors'
+import helmet from 'helmet'
+
+import { config } from 'wasp/server'
+import type { MiddlewareConfig, MiddlewareConfigFn } from 'wasp/server/middleware'
+export type { MiddlewareConfig, MiddlewareConfigFn } from 'wasp/server/middleware'
+
+{=# globalMiddlewareConfigFn.isDefined =}
+{=& globalMiddlewareConfigFn.importStatement =}
+{=/ globalMiddlewareConfigFn.isDefined =}
+{=^ globalMiddlewareConfigFn.isDefined =}
+const {=& globalMiddlewareConfigFn.importAlias =} = (mc: MiddlewareConfig) => mc
+{=/ globalMiddlewareConfigFn.isDefined =}
+
+// This is the set of middleware Wasp supplies by default.
+// NOTE: Remember to update the docs of these change.
+const defaultGlobalMiddlewareConfig: MiddlewareConfig = new Map([
+  ['helmet', helmet()],
+  ['cors', cors({ origin: config.allowedCORSOrigins })],
+  ['logger', logger('dev')],
+  ['express.json', express.json()],
+  ['express.urlencoded', express.urlencoded()],
+  ['cookieParser', cookieParser()]
+])
+
+// This is the global middleware that is the result of applying the user's modifications.
+// It will be used as the basis for Operations and APIs (unless they are further customized).
+const globalMiddlewareConfig: MiddlewareConfig = {=& globalMiddlewareConfigFn.importAlias =}(defaultGlobalMiddlewareConfig)
+
+// This function returns an array of Express middleware to be used by a router. It optionally
+// accepts a function that can modify the global middleware for specific route customization.
+export function globalMiddlewareConfigForExpress(middlewareConfigFn?: MiddlewareConfigFn): express.RequestHandler[] {
+  if (!middlewareConfigFn) {
+    return Array.from(globalMiddlewareConfig.values())
+  }
+
+  // Make a clone so they can't mess up the global Map for any other routes calling this.
+  const globalMiddlewareConfigClone = new Map(globalMiddlewareConfig)
+  const modifiedMiddlewareConfig = middlewareConfigFn(globalMiddlewareConfigClone)
+  return Array.from(modifiedMiddlewareConfig.values())
+}

package/data/Generator/templates/server/src/middleware/index.ts

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

package/data/Generator/templates/server/src/middleware/operations.ts

@@ -0,0 +1,28 @@
+{{={= =}=}}
+import { deserialize, serialize } from 'wasp/core/serialization'
+import { defineHandler } from 'wasp/server/utils'
+{=# isAuthEnabled =}
+import { makeAuthUserIfPossible } from 'wasp/auth/user'
+{=/ isAuthEnabled =}
+
+export function createOperation (handlerFn) {
+    return defineHandler(async (req, res) => {
+        const args = (req.body && deserialize(req.body)) || {}
+        const context = {
+            {=# isAuthEnabled =}
+            user: makeAuthUserIfPossible(req.user),
+            {=/ isAuthEnabled =}
+        }
+        const result = await handlerFn(args, context)
+        const serializedResult = serialize(result)
+        res.json(serializedResult)
+    })
+}
+
+export function createQuery(handlerFn) {
+    return createOperation(handlerFn)
+}
+
+export function createAction(handlerFn) {
+    return createOperation(handlerFn)
+}

package/data/Generator/templates/server/src/queries/_query.ts

@@ -0,0 +1,18 @@
+{{={= =}=}}
+import { prisma } from 'wasp/server'
+
+{=& jsFn.importStatement =}
+
+{=! 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. =}
+
+export default async function (args, context) {
+  return ({= jsFn.importIdentifier =} as any)(args, {
+    ...context,
+    entities: {
+      {=# entities =}
+      {= name =}: prisma.{= prismaIdentifier =},
+      {=/ entities =}
+    },
+  })
+}

package/data/Generator/templates/server/src/routes/apis/index.ts

@@ -0,0 +1,67 @@
+{{={= =}=}}
+import express from 'express'
+import { prisma } from 'wasp/server'
+import { defineHandler } from 'wasp/server/utils'
+import { MiddlewareConfigFn, globalMiddlewareConfigForExpress } from '../../middleware/index.js'
+{=# isAuthEnabled =}
+import auth from 'wasp/core/auth'
+import { type AuthUserData, makeAuthUserIfPossible } from 'wasp/auth/user'
+{=/ isAuthEnabled =}
+
+{=# apiNamespaces =}
+{=& namespaceMiddlewareConfigFnImportStatement =}
+{=/ apiNamespaces =}
+
+{=# apiRoutes =}
+{=& importStatement =}
+{=# routeMiddlewareConfigFn.isDefined =}
+{=& routeMiddlewareConfigFn.importStatement =}
+{=/ routeMiddlewareConfigFn.isDefined =}
+{=/ apiRoutes =}
+
+const idFn: MiddlewareConfigFn = x => x
+
+{=# apiRoutes =}
+{=^ routeMiddlewareConfigFn.isDefined =}
+const {=& routeMiddlewareConfigFn.importAlias =} = idFn
+{=/ routeMiddlewareConfigFn.isDefined =}
+{=/ apiRoutes =}
+
+const router = express.Router()
+
+{=# apiNamespaces =}
+router.use('{= namespacePath =}', globalMiddlewareConfigForExpress({= namespaceMiddlewareConfigFnImportAlias =}))
+{=/ apiNamespaces =}
+
+{=# apiRoutes =}
+const {= apiName =}Middleware = globalMiddlewareConfigForExpress({= routeMiddlewareConfigFn.importAlias =})
+router.{= routeMethod =}(
+  '{= routePath =}',
+  {=# usesAuth =}
+  [auth, ...{= apiName =}Middleware],
+  {=/ usesAuth =}
+  {=^ usesAuth =}
+  {= apiName =}Middleware,
+  {=/ usesAuth =}
+  defineHandler(
+    (
+      req: Parameters<typeof {= importIdentifier =}>[0]{=# usesAuth =} & { user: AuthUserData | null }{=/ usesAuth =},
+      res: Parameters<typeof {= importIdentifier =}>[1],
+    ) => {
+      const context = {
+        {=# usesAuth =}
+        user: makeAuthUserIfPossible(req.user),
+        {=/ usesAuth =}
+        entities: {
+          {=# entities =}
+          {= name =}: prisma.{= prismaIdentifier =},
+          {=/ entities =}
+        },
+      }
+      return {= importIdentifier =}(req, res, context)
+    }
+  )
+)
+{=/ apiRoutes =}
+
+export default router

package/data/Generator/templates/server/src/routes/auth/index.js

@@ -0,0 +1,16 @@
+{{={= =}=}}
+import express from 'express'
+
+import auth from 'wasp/core/auth'
+import me from './me.js'
+import logout from './logout.js'
+
+import providersRouter from '../../auth/providers/index.js'
+
+const router = express.Router()
+
+router.get('/me', auth, me)
+router.post('/logout', auth, logout)
+router.use('/', providersRouter)
+
+export default router

package/data/Generator/templates/server/src/routes/auth/logout.ts

@@ -0,0 +1,12 @@
+import { defineHandler } from 'wasp/server/utils'
+import { createInvalidCredentialsError } from 'wasp/auth/utils'
+import { invalidateSession } from 'wasp/auth/session'
+
+export default defineHandler(async (req, res) => {
+  if (req.sessionId) {
+    await invalidateSession(req.sessionId)
+    res.json({ success: true })
+  } else {
+    throw createInvalidCredentialsError()
+  }
+})

package/data/Generator/templates/server/src/routes/auth/me.ts

@@ -0,0 +1,10 @@
+import { serialize } from 'wasp/core/serialization'
+import { defineHandler } from 'wasp/server/utils'
+
+export default defineHandler(async (req, res) => {
+  if (req.user) {
+    res.json(serialize(req.user))
+  } else {
+    res.json(serialize(null))
+  }
+})

package/data/Generator/templates/server/src/routes/crud/_crud.ts

@@ -0,0 +1,46 @@
+{{={= =}=}}
+import express from 'express'
+import * as crud from '../../crud/{= crud.name =}.js'
+import { createAction, createQuery } from '../../middleware/operations.js'
+{=# isAuthEnabled =}
+import auth from 'wasp/core/auth'
+{=/ isAuthEnabled =}
+
+const _waspRouter = express.Router()
+
+{=# isAuthEnabled =}
+_waspRouter.use(auth)
+{=/ isAuthEnabled =}
+
+{=# crud.operations.Get =}
+_waspRouter.post(
+    '/{= route =}',
+    createQuery(crud.getFn),
+)
+{=/ crud.operations.Get =}
+{=# crud.operations.GetAll =}
+_waspRouter.post(
+    '/{= route =}',
+    createQuery(crud.getAllFn),
+)
+{=/ crud.operations.GetAll =}
+{=# crud.operations.Create =}
+_waspRouter.post(
+    '/{= route =}',
+    createAction(crud.createFn),
+)
+{=/ crud.operations.Create =}
+{=# crud.operations.Update =}
+_waspRouter.post(
+    '/{= route =}',
+    createAction(crud.updateFn),
+)
+{=/ crud.operations.Update =}
+{=# crud.operations.Delete =}
+_waspRouter.post(
+    '/{= route =}',
+    createAction(crud.deleteFn),
+)
+{=/ crud.operations.Delete =}
+
+export const {= crud.name =} = _waspRouter

package/data/Generator/templates/server/src/routes/crud/index.ts

@@ -0,0 +1,12 @@
+{{={= =}=}}
+import express from 'express'
+
+{=# crudRouters =}
+{=& importStatement =}
+{=/ crudRouters =}
+
+export const rootCrudRouter = express.Router()
+
+{=# crudRouters =}
+rootCrudRouter.use('/{= route =}', {= importIdentifier =})
+{=/ crudRouters =}

package/data/Generator/templates/server/src/routes/index.js

@@ -0,0 +1,55 @@
+{{={= =}=}}
+import express from 'express'
+import operations from './operations/index.js'
+import { globalMiddlewareConfigForExpress } from '../middleware/index.js'
+{=# isAuthEnabled =}
+import auth from './auth/index.js'
+{=/ isAuthEnabled =}
+{=# areThereAnyCustomApiRoutes =}
+import apis from './apis/index.js'
+{=/ areThereAnyCustomApiRoutes =}
+{=# areThereAnyCrudRoutes =}
+import { rootCrudRouter } from './crud/index.js'
+{=/ areThereAnyCrudRoutes =}
+{=# isDevelopment =}
+import { config } from 'wasp/server'
+import { makeWrongPortPage } from '../views/wrong-port.js'
+{=/ isDevelopment =}
+
+
+const router = express.Router()
+const middleware = globalMiddlewareConfigForExpress()
+
+router.get('/', middleware,
+  {=# isDevelopment =}
+    function (_req, res) {
+      const data = {
+        appName: "{= appName =}",
+        frontendUrl: config.frontendUrl
+      };
+      const wrongPortPage = makeWrongPortPage(data);
+      res.status(200).type('html').send(wrongPortPage);
+    }
+  {=/ isDevelopment =}
+  {=^ isDevelopment =}
+    function (_req, res) {
+      res.status(200).send();
+    }
+  {=/ isDevelopment =}
+)
+
+{=# isAuthEnabled =}
+router.use('/auth', middleware, auth)
+{=/ isAuthEnabled =}
+router.use('/{= operationsRouteInRootRouter =}', middleware, operations)
+{=# areThereAnyCrudRoutes =}
+router.use('/{= crudRouteInRootRouter =}', middleware, rootCrudRouter)
+{=/ areThereAnyCrudRoutes =}
+{=# areThereAnyCustomApiRoutes =}
+// NOTE: Keep user-defined api routes last so they cannot override our routes.
+// Additionally, do not add middleware to these routes here. Instead, we add
+// it later to allow for middleware customization.
+router.use(apis)
+{=/ areThereAnyCustomApiRoutes =}
+
+export default router

package/data/Generator/templates/server/src/routes/operations/_action.js

@@ -0,0 +1,5 @@
+{{={= =}=}}
+import { createAction } from '../../middleware/operations.js'
+{=& operation.importStatement =}
+
+export default createAction({= operation.importIdentifier =})

package/data/Generator/templates/server/src/routes/operations/_query.js

@@ -0,0 +1,5 @@
+{{={= =}=}}
+import { createQuery } from '../../middleware/operations.js'
+{=& operation.importStatement =}
+
+export default createQuery({= operation.importIdentifier =})

package/data/Generator/templates/server/src/routes/operations/index.js

@@ -0,0 +1,18 @@
+{{={= =}=}}
+import express from 'express'
+
+{=# isAuthEnabled =}
+import auth from 'wasp/core/auth'
+{=/ isAuthEnabled =}
+
+{=# operationRoutes =}
+{=& importStatement =}
+{=/ operationRoutes =}
+
+const router = express.Router()
+
+{=# operationRoutes =}
+router.post('{= routePath =}',{=# isUsingAuth =} auth,{=/ isUsingAuth =} {= importIdentifier =})
+{=/ operationRoutes =}
+
+export default router

package/data/Generator/templates/server/src/server.ts

@@ -0,0 +1,76 @@
+{{={= =}=}}
+import http from 'http'
+
+import app from './app.js'
+import { config } from 'wasp/server'
+
+{=# setupFn.isDefined =}
+{=& setupFn.importStatement =}
+import { ServerSetupFn } from 'wasp/server'
+import { ServerSetupFnContext } from 'wasp/server/types'
+{=/ setupFn.isDefined =}
+
+{=# isPgBossJobExecutorUsed =}
+import { startPgBoss } from 'wasp/server/jobs/core/pgBoss'
+import './jobs/core/allJobs.js'
+{=/ isPgBossJobExecutorUsed =}
+
+{=# userWebSocketFn.isDefined =}
+import { init as initWebSocket } from './webSocket/initialization.js'
+{=/ userWebSocketFn.isDefined =}
+
+const startServer = async () => {
+  {=# isPgBossJobExecutorUsed =}
+  await startPgBoss()
+  {=/ isPgBossJobExecutorUsed =}
+
+  const port = normalizePort(config.port)
+  app.set('port', port)
+
+  const server = http.createServer(app)
+
+  {=# setupFn.isDefined =}
+  const serverSetupFnContext: ServerSetupFnContext = { app, server }
+  await ({= setupFn.importIdentifier =} as ServerSetupFn)(serverSetupFnContext)
+  {=/ setupFn.isDefined =}
+
+  {=# userWebSocketFn.isDefined =}
+  await initWebSocket(server)
+  {=/ userWebSocketFn.isDefined =}
+
+  server.listen(port)
+
+  server.on('error', (error: NodeJS.ErrnoException) => {
+    if (error.syscall !== 'listen') throw error
+    const bind = typeof port === 'string' ? 'Pipe ' + port : 'Port ' + port
+    // handle specific listen errors with friendly messages
+    switch (error.code) {
+    case 'EACCES':
+      console.error(bind + ' requires elevated privileges')
+      process.exit(1)
+    case 'EADDRINUSE':
+      console.error(bind + ' is already in use')
+      process.exit(1)
+    default:
+      throw error
+    }
+  })
+
+  server.on('listening', () => {
+    const addr = server.address()
+    const bind = typeof addr === 'string' ? 'pipe ' + addr : 'port ' + addr.port
+    console.log('Server listening on ' + bind)
+  })
+}
+
+startServer().catch(e => console.error(e))
+
+/**
+ * Normalize a port into a number, string, or false.
+ */
+function normalizePort (val) {
+  const port = parseInt(val, 10)
+  if (isNaN(port)) return val // named pipe
+  if (port >= 0) return port // port number
+  return false
+}