sst 3.0.5 → 3.0.6

package/dist/auth/adapter/code.js

@@ -1,6 +1,6 @@
-import * as jose from "jose";
 import { deleteCookie, getCookie } from "hono/cookie";
 import { UnknownStateError } from "../index.js";
+import { CompactEncrypt, compactDecrypt } from "jose";
 export function CodeAdapter(config) {
     const length = config.length || 6;
     function generate() {
@@ -18,7 +18,7 @@ export function CodeAdapter(config) {
             delete claims["redirect_uri"];
             delete claims["response_type"];
             delete claims["provider"];
-            const authorization = await new jose.CompactEncrypt(new TextEncoder().encode(JSON.stringify({
+            const authorization = await new CompactEncrypt(new TextEncoder().encode(JSON.stringify({
                 claims,
                 code,
             })))
@@ -31,9 +31,7 @@ export function CodeAdapter(config) {
             const authorization = getCookie(c, "authorization");
             if (!authorization)
                 throw new UnknownStateError();
-            const { code, claims } = JSON.parse(new TextDecoder().decode(await jose
-                .compactDecrypt(authorization, await ctx.encryption.privateKey)
-                .then((value) => value.plaintext)));
+            const { code, claims } = JSON.parse(new TextDecoder().decode(await compactDecrypt(authorization, await ctx.encryption.privateKey).then((value) => value.plaintext)));
             if (!code || !claims) {
                 return ctx.forward(c, await config.onCodeInvalid(code, claims, c.req.raw));
             }

package/dist/auth/adapter/link.js

@@ -1,8 +1,8 @@
-import * as jose from "jose";
+import { SignJWT, jwtVerify } from "jose";
 export function LinkAdapter(config) {
     return function (routes, ctx) {
         routes.get("/authorize", async (c) => {
-            const token = await new jose.SignJWT(c.req.query())
+            const token = await new SignJWT(c.req.query())
                 .setProtectedHeader({ alg: ctx.algorithm })
                 .setExpirationTime("10m")
                 .sign(await ctx.signing.privateKey);
@@ -19,7 +19,7 @@ export function LinkAdapter(config) {
             const token = c.req.query("token");
             if (!token)
                 throw new Error("Missing token parameter");
-            const verified = await jose.jwtVerify(token, await ctx.signing.publicKey);
+            const verified = await jwtVerify(token, await ctx.signing.publicKey);
             const resp = await ctx.success(c, { claims: verified.payload });
             return resp;
         });

package/dist/auth/handler.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Adapter } from "./adapter/adapter.js";
-import * as jose from "jose";
+import { JWTPayload } from "jose";
 import { SessionBuilder } from "./session.js";
 import { Hono } from "hono/tiny";
 interface OnSuccessResponder<T extends {
     type: any;
     properties: any;
 }> {
-    session(input: T & jose.JWTPayload): Promise<Response>;
+    session(input: T & JWTPayload): Promise<Response>;
 }
 export declare class UnknownProviderError extends Error {
     provider?: string | undefined;

package/dist/auth/handler.js

@@ -1,4 +1,4 @@
-import * as jose from "jose";
+import { SignJWT, importPKCS8, importSPKI, jwtVerify } from "jose";
 import { Hono } from "hono/tiny";
 import { deleteCookie, getCookie, setCookie } from "hono/cookie";
 export class UnknownProviderError extends Error {
@@ -48,12 +48,12 @@ export function AuthHandler(input) {
     }
     const options = {
         signing: {
-            privateKey: jose.importPKCS8(process.env.AUTH_PRIVATE_KEY, "RS512"),
-            publicKey: jose.importSPKI(process.env.AUTH_PUBLIC_KEY, "RS512"),
+            privateKey: importPKCS8(process.env.AUTH_PRIVATE_KEY, "RS512"),
+            publicKey: importSPKI(process.env.AUTH_PUBLIC_KEY, "RS512"),
         },
         encryption: {
-            privateKey: jose.importPKCS8(process.env.AUTH_PRIVATE_KEY, "RSA-OAEP-512"),
-            publicKey: jose.importSPKI(process.env.AUTH_PUBLIC_KEY, "RSA-OAEP-512"),
+            privateKey: importPKCS8(process.env.AUTH_PRIVATE_KEY, "RSA-OAEP-512"),
+            publicKey: importSPKI(process.env.AUTH_PUBLIC_KEY, "RSA-OAEP-512"),
         },
         algorithm: "RS512",
         async success(ctx, properties) {
@@ -64,7 +64,7 @@ export function AuthHandler(input) {
             }
             return await input.callbacks.auth.success({
                 async session(session) {
-                    const token = await new jose.SignJWT(session)
+                    const token = await new SignJWT(session)
                         .setProtectedHeader({ alg: "RS512" })
                         .setExpirationTime("1yr")
                         .sign(await options.signing.privateKey);
@@ -83,7 +83,7 @@ export function AuthHandler(input) {
                         // This allows the code to be reused within a 30 second window
                         // The code should be single use but we're making this tradeoff to remain stateless
                         // In the future can store this in a dynamo table to ensure single use
-                        const code = await new jose.SignJWT({
+                        const code = await new SignJWT({
                             client_id,
                             redirect_uri,
                             token,
@@ -129,7 +129,7 @@ export function AuthHandler(input) {
             c.status(400);
             return c.text("Missing code");
         }
-        const { payload } = await jose.jwtVerify(code, await options.signing.publicKey);
+        const { payload } = await jwtVerify(code, await options.signing.publicKey);
         if (payload.redirect_uri !== form.get("redirect_uri")) {
             c.status(400);
             return c.text("redirect_uri mismatch");

package/dist/auth/session.d.ts

@@ -7,6 +7,13 @@ export declare function createSessionBuilder<SessionTypes extends Record<string,
         type: "public";
         properties: {};
     }>;
+    create(session: { [type in keyof SessionTypes]: {
+        type: type;
+        properties: SessionTypes[type];
+    }; }[keyof SessionTypes] | {
+        type: "public";
+        properties: {};
+    }): Promise<string>;
     $type: SessionTypes;
     $typeValues: { [type in keyof SessionTypes]: {
         type: type;

package/dist/auth/session.js

@@ -1,4 +1,4 @@
-import { importSPKI, jwtVerify } from "jose";
+import { SignJWT, importPKCS8, importSPKI, jwtVerify } from "jose";
 import { Resource } from "../resource.js";
 export function createSessionBuilder() {
     return {
@@ -11,6 +11,14 @@ export function createSessionBuilder() {
             const result = await jwtVerify(token, await importSPKI(publicKey, "RS512"));
             return result.payload;
         },
+        async create(session) {
+            const privateKey = await importPKCS8(process.env.AUTH_PRIVATE_KEY, "RS512");
+            const token = await new SignJWT(session)
+                .setProtectedHeader({ alg: "RS512" })
+                .setExpirationTime("1yr")
+                .sign(privateKey);
+            return token;
+        },
         $type: {},
         $typeValues: {},
     };

package/package.json

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