sst 3.0.1-23 → 3.0.1-25

package/dist/auth/handler.d.ts

@@ -39,17 +39,17 @@ export declare function AuthHandler<Providers extends Record<string, Adapter<any
     session?: Sessions;
     providers: Providers;
     callbacks: {
-        index?(event: Request): Promise<Response>;
-        error?(error: UnknownStateError): Promise<Response | undefined>;
+        index?(req: Request): Promise<Response>;
+        error?(error: UnknownStateError, req: Request): Promise<Response | undefined>;
         auth: {
-            error?(error: MissingParameterError | UnauthorizedClientError | UnknownProviderError): Promise<Response>;
+            error?(error: MissingParameterError | UnauthorizedClientError | UnknownProviderError, req: Request): Promise<Response>;
             start?(event: Request): Promise<void>;
-            allowClient(clientID: string, redirect: string): Promise<boolean>;
-            success(response: OnSuccessResponder<Sessions["$typeValues"]>, input: Result): Promise<Response>;
+            allowClient(clientID: string, redirect: string, req: Request): Promise<boolean>;
+            success(response: OnSuccessResponder<Sessions["$typeValues"]>, input: Result, req: Request): Promise<Response>;
         };
         connect?: {
-            error?(error: InvalidSessionError | UnknownProviderError): Promise<Response | undefined>;
-            start?(session: Sessions["$typeValues"], event: Request): Promise<void>;
+            error?(error: InvalidSessionError | UnknownProviderError, req: Request): Promise<Response | undefined>;
+            start?(session: Sessions["$typeValues"], req: Request): Promise<void>;
             success?(session: Sessions["$typeValues"], input: {}): Promise<Response>;
         };
     };

package/dist/auth/handler.js

@@ -62,7 +62,7 @@ export function AuthHandler(input) {
             const redirect_uri = getCookie(ctx, "redirect_uri");
             const response_type = getCookie(ctx, "response_type");
             if (!redirect_uri) {
-                return options.forward(ctx, await input.callbacks.auth.error(new UnknownStateError()));
+                return options.forward(ctx, await input.callbacks.auth.error(new UnknownStateError(), ctx.req.raw));
             }
             return await input.callbacks.auth.success({
                 async session(session) {
@@ -101,7 +101,7 @@ export function AuthHandler(input) {
                     ctx.status(400);
                     return ctx.text(`Unsupported response_type: ${response_type}`);
                 },
-            }, properties);
+            }, properties, ctx.req.raw);
         },
         forward(ctx, response) {
             return ctx.newResponse(response.body, response.status, Object.fromEntries(response.headers.entries()));
@@ -176,7 +176,7 @@ export function AuthHandler(input) {
         });
         app.route(`/${name}`, route);
     }
-    app.all("/*", async (c, next) => {
+    app.all("/*", async (c) => {
         return c.notFound();
     });
     console.log(app.routes);

package/dist/auth/session.d.ts

@@ -1,20 +1,12 @@
-import { JWTPayload } from "jose";
 export type SessionBuilder = ReturnType<typeof createSessionBuilder>;
 export declare function createSessionBuilder<SessionTypes extends Record<string, any> = {}>(): {
-    create<T extends ({ [type in keyof SessionTypes]: {
+    verify(token: string): Promise<{ [type in keyof SessionTypes]: {
         type: type;
         properties: SessionTypes[type];
     }; }[keyof SessionTypes] | {
         type: "public";
         properties: {};
-    })["type"]>(type: T, properties: SessionTypes[T], options?: JWTPayload): void;
-    verify(token: string): { [type in keyof SessionTypes]: {
-        type: type;
-        properties: SessionTypes[type];
-    }; }[keyof SessionTypes] | {
-        type: "public";
-        properties: {};
-    };
+    }>;
     $type: SessionTypes;
     $typeValues: { [type in keyof SessionTypes]: {
         type: type;

package/dist/auth/session.js

@@ -1,8 +1,15 @@
+import { importSPKI, jwtVerify } from "jose";
+import { Resource } from "../resource.js";
 export function createSessionBuilder() {
+    const auth = Object.values(Resource).find((value) => value.auth === true && value.publicKey);
+    if (!auth) {
+        throw new Error("No auth resource found");
+    }
+    const publicKey = auth.publicKey;
     return {
-        create(type, properties, options) { },
-        verify(token) {
-            return {};
+        async verify(token) {
+            const result = await jwtVerify(token, await importSPKI(publicKey, "RS512"));
+            return result.payload;
         },
         $type: {},
         $typeValues: {},

package/dist/resource.js

@@ -1,15 +1,16 @@
-import { env } from "node:process";
-export const Resource = new Proxy({}, {
+const raw = {
+    // @ts-expect-error,
+    ...globalThis.$SST_LINKS,
+};
+for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith("SST_RESOURCE_") && value) {
+        raw[key.slice("SST_RESOURCE_".length)] = JSON.parse(value);
+    }
+}
+export const Resource = new Proxy(raw, {
     get(target, prop) {
-        // Read from environment first
-        const envName = `SST_RESOURCE_${prop}`;
-        if (env[envName]) {
-            return JSON.parse(env[envName]);
-        }
-        // @ts-expect-error
-        if (prop in (globalThis.$SST_LINKS || {})) {
-            // @ts-expect-error
-            return globalThis.$SST_LINKS[prop];
+        if (prop in target) {
+            return target[prop];
         }
         throw new Error(`"${prop}" is not linked`);
     },

package/package.json

@@ -3,7 +3,7 @@
   "name": "sst",
   "type": "module",
   "sideEffects": false,
-  "version": "3.0.1-23",
+  "version": "3.0.1-25",
   "main": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",