sst 0.0.508 → 0.0.509

package/dist/scripts/release.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/scripts/release.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+import { $ } from "bun";
+const version = process.argv[2];
+await $ `bun run build`;
+const pkg = await Bun.file("package.json").json();
+try {
+    await Bun.write("package.json", JSON.stringify({ ...pkg, version }, null, 2));
+    await $ `npm publish --access public --tag ion`;
+}
+finally {
+    await Bun.write("package.json", JSON.stringify(pkg, null, 2));
+}

package/dist/src/auth/adapter/oauth.js

@@ -8,13 +8,16 @@ export const OauthAdapter =
 (config) => {
     return async function (routes, ctx) {
         function getClient(c) {
-            const callback = c.req.url.replace(/authorize\/.*$/, "callback");
+            const callback = new URL(c.req.url);
+            callback.pathname = callback.pathname.replace(/authorize.*$/, "callback");
+            callback.search = "";
+            callback.host = c.req.header("x-forwarded-host") || callback.host;
             return [
                 callback,
                 new config.issuer.Client({
                     client_id: config.clientID,
                     client_secret: config.clientSecret,
-                    redirect_uris: [callback],
+                    redirect_uris: [callback.toString()],
                     response_types: ["code"],
                 }),
             ];
@@ -46,7 +49,7 @@ export const OauthAdapter =
             const state = getCookie(c, "auth_state");
             const tokenset = await client[config.issuer.metadata.userinfo_endpoint
                 ? "callback"
-                : "oauthCallback"](callback, query, {
+                : "oauthCallback"](callback.toString(), query, {
                 code_verifier,
                 state,
             });
@@ -66,7 +69,7 @@ export const OauthAdapter =
             const state = getCookie(c, "auth_state");
             const tokenset = await client[config.issuer.metadata.userinfo_endpoint
                 ? "callback"
-                : "oauthCallback"](callback, Object.fromEntries(form), {
+                : "oauthCallback"](callback.toString(), Object.fromEntries(form), {
                 code_verifier,
                 state,
             });

package/dist/src/auth/adapter/oidc.js

@@ -3,10 +3,13 @@ import { getCookie } from "hono/cookie";
 export const OidcAdapter = /* @__PURE__ */ (config) => {
     return async function (routes, ctx) {
         routes.get("/authorize", async (c) => {
-            const callback = c.req.url.replace(/authorize\/.*$/, "callback");
+            const callback = new URL(c.req.url);
+            callback.pathname = callback.pathname.replace(/authorize.*$/, "callback");
+            callback.search = "";
+            callback.host = c.req.header("x-forwarded-host") || callback.host;
             const client = new config.issuer.Client({
                 client_id: config.clientID,
-                redirect_uris: [callback],
+                redirect_uris: [callback.toString()],
                 response_types: ["id_token"],
             });
             const nonce = generators.nonce();

package/dist/src/auth/handler.d.ts

@@ -3,7 +3,7 @@ import { Adapter } from "./adapter/adapter.js";
 import { JWTPayload } from "jose";
 import { SessionBuilder } from "./session.js";
 import { Hono } from "hono/tiny";
-interface OnSuccessResponder<T extends {
+export interface OnSuccessResponder<T extends {
     type: any;
     properties: any;
 }> {
@@ -55,4 +55,3 @@ export declare function AuthHandler<Providers extends Record<string, Adapter<any
         };
     };
 }): Hono<import("hono").Env, import("hono/types").BlankSchema, "/">;
-export {};

package/dist/src/aws/auth.d.ts

@@ -0,0 +1,9 @@
+import { Handler } from "aws-lambda";
+import { Adapter } from "../auth/adapter/adapter.js";
+import { AuthHandler } from "../auth/handler.js";
+import { SessionBuilder, createSessionBuilder } from "../auth/session.js";
+export declare namespace auth {
+    type Issuer = import("openid-client").Issuer;
+    function authorizer<Providers extends Record<string, Adapter<any>>, Sessions extends SessionBuilder>(...args: Parameters<typeof AuthHandler<Providers, Sessions>>): Handler<any, any>;
+    const sessions: typeof createSessionBuilder;
+}

package/dist/src/aws/auth.js

@@ -0,0 +1,12 @@
+import { AuthHandler } from "../auth/handler.js";
+import { createSessionBuilder } from "../auth/session.js";
+import { handle, streamHandle } from "hono/aws-lambda";
+export var auth;
+(function (auth) {
+    function authorizer(...args) {
+        const hono = AuthHandler(...args);
+        return (process.env.SST_LIVE ? handle(hono) : streamHandle(hono));
+    }
+    auth.authorizer = authorizer;
+    auth.sessions = createSessionBuilder;
+})(auth || (auth = {}));

package/dist/src/aws/bus.js

@@ -2,8 +2,9 @@ import { client } from "../aws/client.js";
 import { Resource } from "../resource.js";
 export var bus;
 (function (bus) {
-    function url(options) {
-        const region = options?.region || client.region;
+    function url(region, options) {
+        if (options?.region)
+            region = options.region;
         return `https://events.${region}.amazonaws.com/`;
     }
     function subscriber(_events, cb) {
@@ -22,15 +23,16 @@ export var bus;
      * */
     bus.handler = subscriber;
     async function publish(name, def, properties, options) {
-        const u = url(options?.aws);
+        const c = await client();
+        const u = url(c.region, options?.aws);
         const evt = typeof def === "string"
             ? {
                 type: def,
                 properties,
                 metadata: options?.metadata || {},
             }
-            : await def.create(properties);
-        const res = await client.fetch(u, {
+            : await def.create(properties, options?.metadata);
+        const res = await c.fetch(u, {
             method: "POST",
             aws: options?.aws,
             headers: {
@@ -44,7 +46,7 @@ export var bus;
                         DetailType: evt.type,
                         Detail: JSON.stringify({
                             metadata: evt.metadata,
-                            payload: evt.properties,
+                            properties: evt.properties,
                         }),
                         EventBusName: typeof name === "string" ? name : name.name,
                     },

package/dist/src/aws/client.d.ts

@@ -1,3 +1,3 @@
 import { AwsClient } from "aws4fetch";
-export declare const client: AwsClient;
+export declare function client(): Promise<AwsClient>;
 export type AwsOptions = Exclude<Parameters<AwsClient["fetch"]>[1], null | undefined>["aws"];

package/dist/src/aws/client.js

@@ -1,7 +1,36 @@
 import { AwsClient } from "aws4fetch";
-export const client = new AwsClient({
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    sessionToken: process.env.AWS_SESSION_TOKEN,
-    region: process.env.AWS_REGION,
-});
+let cachedCredentials = null;
+async function getCredentials(url) {
+    if (cachedCredentials) {
+        const currentTime = new Date();
+        const fiveMinutesFromNow = new Date(currentTime.getTime() + 5 * 60000);
+        const expirationTime = new Date(cachedCredentials.Expiration);
+        if (expirationTime > fiveMinutesFromNow) {
+            return cachedCredentials;
+        }
+    }
+    const credentials = (await fetch(url).then((res) => res.json()));
+    cachedCredentials = credentials;
+    return credentials;
+}
+export async function client() {
+    if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
+        return new AwsClient({
+            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+            sessionToken: process.env.AWS_SESSION_TOKEN,
+            region: process.env.AWS_REGION,
+        });
+    }
+    if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
+        const credentials = await getCredentials("http://169.254.170.2" +
+            process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI);
+        return new AwsClient({
+            accessKeyId: credentials.AccessKeyId,
+            secretAccessKey: credentials.SecretAccessKey,
+            sessionToken: credentials.Token,
+            region: process.env.AWS_REGION,
+        });
+    }
+    throw new Error("No AWS credentials found");
+}

package/dist/src/aws/realtime.d.ts

@@ -1,4 +1,4 @@
-import { IoTCustomAuthorizerHandler } from "aws-lambda";
+import { Context, IoTCustomAuthorizerEvent } from "aws-lambda";
 export declare namespace realtime {
     interface AuthResult {
         /**
@@ -57,5 +57,22 @@ export declare namespace realtime {
      * });
      * ```
      */
-    function authorizer(input: (token: string) => Promise<AuthResult>): IoTCustomAuthorizerHandler;
+    function authorizer(input: (token: string) => Promise<AuthResult>): (evt: IoTCustomAuthorizerEvent, context: Context) => Promise<{
+        isAuthenticated: boolean;
+        principalId: string;
+        disconnectAfterInSeconds: number;
+        refreshAfterInSeconds: number;
+        policyDocuments: {
+            Version: string;
+            Statement: ({
+                Action: string;
+                Effect: string;
+                Resource: string;
+            } | {
+                Action: string;
+                Effect: string;
+                Resource: string[];
+            })[];
+        }[];
+    }>;
 }

package/dist/src/event/index.d.ts

@@ -1,4 +1,3 @@
-import { ZodSchema, z } from "zod";
 export declare namespace event {
     export type Definition = {
         type: string;
@@ -8,8 +7,8 @@ export declare namespace event {
         $payload: any;
         create: (...args: any[]) => Promise<any>;
     };
-    export function builder<Metadata extends ((type: string, properties: any) => any) | Parameters<Validator>[0], Validator extends (schema: any) => (input: any) => any = typeof ZodValidator>(input: {
-        validator?: Validator;
+    export function builder<Metadata extends ((type: string, properties: any) => any) | Parameters<Validator>[0], Validator extends (schema: any) => (input: any) => any>(input: {
+        validator: Validator;
         metadata?: Metadata;
     }): {
         <Type extends string, Schema extends Parameters<Validator>[0]>(type: Type, schema: Schema): {
@@ -36,7 +35,6 @@ export declare namespace event {
             type: K;
         }>["$payload"]; }[Events["type"]];
     };
-    export function ZodValidator<Schema extends ZodSchema>(schema: Schema): (input: z.input<Schema>) => z.output<Schema>;
     type ParserZodEsque<TInput, TParsedInput> = {
         _input: TInput;
         _output: TParsedInput;

package/dist/src/event/index.js

@@ -1,7 +1,7 @@
 export var event;
 (function (event) {
     function builder(input) {
-        const validator = input.validator || ZodValidator;
+        const validator = input.validator;
         const fn = function event(type, schema) {
             const validate = validator(schema);
             async function create(properties, metadata) {
@@ -32,10 +32,4 @@ export var event;
         return fn;
     }
     event.builder = builder;
-    function ZodValidator(schema) {
-        return (input) => {
-            return schema.parse(input);
-        };
-    }
-    event.ZodValidator = ZodValidator;
 })(event || (event = {}));

package/dist/src/event/validator.d.ts

@@ -0,0 +1,4 @@
+import { ZodSchema, z } from "zod";
+export declare function ZodValidator<Schema extends ZodSchema>(schema: Schema): (input: z.input<Schema>) => z.output<Schema>;
+import { BaseSchema, Input } from "valibot";
+export declare function ValibotValidator<T extends BaseSchema>(schema: T): (value: Input<T>) => import("valibot").Output<T>;

package/dist/src/event/validator.js

@@ -0,0 +1,11 @@
+export function ZodValidator(schema) {
+    return (input) => {
+        return schema.parse(input);
+    };
+}
+import { parse } from "valibot";
+export function ValibotValidator(schema) {
+    return (value) => {
+        return parse(schema, value);
+    };
+}

package/dist/src/resource.js

@@ -1,4 +1,4 @@
-import { env } from "node:process";
+import { env } from "process";
 const raw = {
     // @ts-expect-error,
     ...globalThis.$SST_LINKS,
@@ -45,6 +45,10 @@ export const Resource = new Proxy(raw, {
         if (prop in raw) {
             return raw[prop];
         }
-        throw new Error(`"${prop}" is not linked`);
+        let msg = `"${prop}" is not linked`;
+        if (env.AWS_LAMBDA_FUNCTION_NAME) {
+            msg += ` to ${env.AWS_LAMBDA_FUNCTION_NAME}`;
+        }
+        throw new Error(msg);
     },
 });

package/package.json

@@ -3,7 +3,7 @@
   "name": "sst",
   "type": "module",
   "sideEffects": false,
-  "version": "0.0.508",
+  "version": "0.0.509",
   "main": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",
@@ -19,6 +19,7 @@
   },
   "devDependencies": {
     "@tsconfig/node20": "20.1.4",
+    "@types/bun": "^1.1.6",
     "@types/node": "20.11.0",
     "hono": "4.3.9",
     "typescript": "5.3.3",
@@ -47,4 +48,4 @@
     "jose": "5.2.3",
     "openid-client": "5.6.4"
   }
-}
+}