encore.dev 1.44.9 → 1.45.0

package/internal/appinit/mod.ts

@@ -1,9 +1,15 @@
 import { Gateway } from "../../api/gateway";
+import { Middleware, MiddlewareRequest, HandlerResponse } from "../../api/mod";
+import { IterableSocket, IterableStream, Sink } from "../../api/stream";
 import { RawRequest, RawResponse } from "../api/node_http";
 import { setCurrentRequest } from "../reqtrack/mod";
 import * as runtime from "../runtime/mod";
 
-export type Handler = runtime.ApiRoute;
+export type Handler = {
+  apiRoute: runtime.ApiRoute;
+  middlewares: Middleware[];
+  endpointOptions: EndpointOptions;
+};
 
 export function registerHandlers(handlers: Handler[]) {
   runtime.RT.registerHandlers(handlers.map((h) => transformHandler(h)));
@@ -22,104 +28,201 @@ export async function run() {
   return runtime.RT.runForever();
 }
 
-class IterableStream {
-  private stream: runtime.Stream;
-
-  constructor(stream: runtime.Stream) {
-    this.stream = stream;
-  }
+interface EndpointOptions {
+  expose: boolean;
+  auth: boolean;
+  isRaw: boolean;
+  isStream: boolean;
+}
 
-  recv(): Promise<Record<string, any>> {
-    return this.stream.recv();
-  }
+export interface InternalHandlerResponse {
+  payload: any;
+  extraHeaders?: Record<string, string | string[]>;
+}
 
-  async *[Symbol.asyncIterator]() {
-    while (true) {
-      try {
-        yield await this.stream.recv();
-      } catch (e) {
-        break;
-      }
+// recursively calls all middlewares
+async function invokeMiddlewareChain(
+  req: MiddlewareRequest,
+  chain: Middleware[],
+  handler: () => Promise<any>
+): Promise<InternalHandlerResponse> {
+  const execute = async (
+    index: number,
+    req: MiddlewareRequest
+  ): Promise<HandlerResponse> => {
+    const currentMiddleware = chain.at(index);
+
+    // no more middlewares, execute the handler
+    if (currentMiddleware === undefined) {
+      return new HandlerResponse(await handler());
     }
-  }
-}
 
-class IterableSocket {
-  private socket: runtime.Socket;
+    // execute current middleware
+    return currentMiddleware(req, (req) => {
+      return execute(index + 1, req);
+    });
+  };
 
-  constructor(socket: runtime.Socket) {
-    this.socket = socket;
-  }
+  return (await execute(0, req)).__internalToResponse();
+}
 
-  send(msg: Record<string, any>): void {
-    return this.socket.send(msg);
-  }
-  recv(): Promise<Record<string, any>> {
-    return this.socket.recv();
-  }
+// calculate what middlewares should run for an endpoint
+function calculateMiddlewareChain(
+  endpointOptions: EndpointOptions,
+  ms: Middleware[]
+): Middleware[] {
+  let middlewares = [];
+
+  for (const m of ms) {
+    if (m.options === undefined || m.options.target === undefined) {
+      middlewares.push(m);
+    } else {
+      const target = m.options.target;
+      // check if options are set and if they match the endpoint options
+      if (target.auth !== undefined && target.auth !== endpointOptions.auth) {
+        continue;
+      }
 
-  close(): void {
-    this.socket.close();
-  }
+      if (
+        target.expose !== undefined &&
+        target.expose !== endpointOptions.expose
+      ) {
+        continue;
+      }
 
-  async *[Symbol.asyncIterator]() {
-    while (true) {
-      try {
-        yield await this.socket.recv();
-      } catch (e) {
-        break;
+      if (
+        target.isRaw !== undefined &&
+        target.isRaw !== endpointOptions.isRaw
+      ) {
+        continue;
       }
+
+      if (
+        target.isStream !== undefined &&
+        target.isStream !== endpointOptions.isStream
+      ) {
+        continue;
+      }
+
+      middlewares.push(m);
     }
   }
+
+  return middlewares;
 }
 
-function transformHandler(h: Handler): Handler {
-  if (h.streamingResponse || h.streamingRequest) {
+function transformHandler(h: Handler): runtime.ApiRoute {
+  const middlewares = calculateMiddlewareChain(
+    h.endpointOptions,
+    h.middlewares
+  );
+
+  if (h.apiRoute.streamingResponse || h.apiRoute.streamingRequest) {
     return {
-      ...h,
+      ...h.apiRoute,
       // req is the upgrade request.
       // stream is either a bidirectional stream, in stream or out stream.
-      handler: (req: runtime.Request, stream: unknown) => {
+      handler: (
+        req: runtime.Request,
+        stream: runtime.Sink | runtime.Stream | runtime.Socket
+      ) => {
         setCurrentRequest(req);
 
         // make readable streams async iterators
-        if (stream instanceof runtime.Stream) {
-          stream = new IterableStream(stream);
-        }
-        if (stream instanceof runtime.Socket) {
-          stream = new IterableSocket(stream);
+        const streamArg: IterableStream | IterableSocket | Sink =
+          stream instanceof runtime.Stream
+            ? new IterableStream(stream)
+            : stream instanceof runtime.Socket
+              ? new IterableSocket(stream)
+              : new Sink(stream);
+
+        if (middlewares.length === 0) {
+          const payload = req.payload();
+          return toResponse(
+            payload !== null
+              ? h.apiRoute.handler(payload, streamArg)
+              : h.apiRoute.handler(streamArg)
+          );
         }
 
-        // handshake payload
-        const payload = req.payload();
-        return payload !== null
-          ? h.handler(payload, stream)
-          : h.handler(stream);
+        const handler = async () => {
+          // handshake payload
+          const payload = req.payload();
+          return payload !== null
+            ? h.apiRoute.handler(payload, streamArg)
+            : h.apiRoute.handler(streamArg);
+        };
+
+        const mwRequest = new MiddlewareRequest(
+          streamArg,
+          undefined,
+          undefined
+        );
+        return invokeMiddlewareChain(mwRequest, middlewares, handler);
       }
     };
   }
 
-  if (h.raw) {
+  if (h.apiRoute.raw) {
     return {
-      ...h,
+      ...h.apiRoute,
       handler: (
         req: runtime.Request,
         resp: runtime.ResponseWriter,
         body: runtime.BodyReader
       ) => {
         setCurrentRequest(req);
+
         const rawReq = new RawRequest(req, body);
         const rawResp = new RawResponse(rawReq, resp);
-        return h.handler(rawReq, rawResp);
+
+        if (middlewares.length === 0) {
+          return toResponse(h.apiRoute.handler(rawReq, rawResp));
+        }
+
+        const handler = async () => {
+          return h.apiRoute.handler(rawReq, rawResp);
+        };
+
+        const mwRequest = new MiddlewareRequest(undefined, rawReq, rawResp);
+        return invokeMiddlewareChain(mwRequest, middlewares, handler);
       }
     };
   }
+
   return {
-    ...h,
+    ...h.apiRoute,
     handler: (req: runtime.Request) => {
       setCurrentRequest(req);
-      const payload = req.payload();
-      return payload !== null ? h.handler(payload) : h.handler();
+
+      if (middlewares.length === 0) {
+        const payload = req.payload();
+        return toResponse(
+          payload !== null ? h.apiRoute.handler(payload) : h.apiRoute.handler()
+        );
+      }
+
+      const handler = async () => {
+        const payload = req.payload();
+        return payload !== null
+          ? h.apiRoute.handler(payload)
+          : h.apiRoute.handler();
+      };
+
+      const mwRequest = new MiddlewareRequest(undefined, undefined, undefined);
+      return invokeMiddlewareChain(mwRequest, middlewares, handler);
     }
   };
 }
+
+function toResponse(
+  payload: any
+): InternalHandlerResponse | Promise<InternalHandlerResponse> {
+  if (payload instanceof Promise) {
+    return payload.then((payload) => {
+      return new HandlerResponse(payload).__internalToResponse();
+    });
+  } else {
+    return new HandlerResponse(payload).__internalToResponse();
+  }
+}

package/internal/runtime/napi/napi.cjs

@@ -1,5 +1,5 @@
 // The version of the runtime this JS bundle was generated for.
-const version = "v1.44.9";
+const version = "v1.45.0";
 
 // Load the native module.
 const nativeModulePath = process.env.ENCORE_RUNTIME_LIB;

package/internal/runtime/napi/napi.d.cts

@@ -23,6 +23,7 @@ export interface ApiDesc {
   service: string
   endpoint: string
   raw: boolean
+  requiresAuth: boolean
 }
 
 export interface ApiRoute {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "encore.dev",
   "description": "Encore's JavaScript/TypeScript SDK",
-  "version": "1.44.9",
+  "version": "1.45.0",
   "license": "MPL-2.0",
   "bugs": {
     "url": "https://github.com/encoredev/encore/issues"

package/req_meta.ts

@@ -10,6 +10,9 @@ export interface APIDesc {
 
   /** Whether the endpoint is a raw endpoint. */
   raw: boolean;
+
+  /** Whether the endpoint requires auth. */
+  auth: boolean;
 }
 
 export type Method =
@@ -153,7 +156,7 @@ export function currentRequest(): RequestMeta | undefined {
   const meta = req.meta();
 
   const base: BaseRequestMeta = {
-    trace: meta.trace,
+    trace: meta.trace
   };
 
   if (meta.apiCall) {
@@ -163,13 +166,14 @@ export function currentRequest(): RequestMeta | undefined {
         service: meta.apiCall.api.service,
         endpoint: meta.apiCall.api.endpoint,
         raw: meta.apiCall.api.raw,
+        auth: meta.apiCall.api.requiresAuth
       },
       method: meta.apiCall.method as Method,
       path: meta.apiCall.path,
       pathAndQuery: meta.apiCall.pathAndQuery,
       pathParams: meta.apiCall.pathParams ?? {},
       parsedPayload: meta.apiCall.parsedPayload,
-      headers: meta.apiCall.headers,
+      headers: meta.apiCall.headers
     };
     return { ...base, ...api };
   } else if (meta.pubsubMessage) {
@@ -180,7 +184,7 @@ export function currentRequest(): RequestMeta | undefined {
       subscription: meta.pubsubMessage.subscription,
       messageId: meta.pubsubMessage.id,
       deliveryAttempt: meta.pubsubMessage.deliveryAttempt,
-      parsedPayload: meta.pubsubMessage.parsedPayload,
+      parsedPayload: meta.pubsubMessage.parsedPayload
     };
     return { ...base, ...msg };
   } else {

package/service/mod.ts

@@ -1,3 +1,5 @@
+import { Middleware } from "../api/mod";
+
 /**
  * Defines an Encore backend service.
  *
@@ -17,4 +19,6 @@ export class Service {
   }
 }
 
-export interface ServiceConfig {}
+export interface ServiceConfig {
+  middlewares?: Middleware[];
+}

package/storage/sqldb/database.ts

@@ -19,7 +19,7 @@ const driverName = "node-pg";
 export type Row = Record<string, any>;
 
 /** Represents a type that can be used in query template literals */
-export type Primitive = string | number | boolean | Buffer | null;
+export type Primitive = string | number | boolean | Buffer | Date | null;
 
 /**
  * Constructing a new database object will result in Encore provisioning a database with