ts-ag 0.0.1-dev.2 → 1.0.0

package/src/lambda/client-types.ts

@@ -1,4 +1,4 @@
-import type { ErrorBody, SuccessCode, ErrorCode } from './handlerUtils.js';
+import type { ErrorBody, SuccessCode, ErrorCode } from "./handlerUtils.js";
 
 // ----------------- Helpers ----------------------
 // Used to easily extract types from ApiEndpoints types
@@ -9,10 +9,11 @@ import type { ErrorBody, SuccessCode, ErrorCode } from './handlerUtils.js';
  * @template P - Path string literal type (e.g. 'payments/account')
  * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
  */
-export type ApiInput<E extends ApiEndpoints, P extends E['path'], M extends E['method']> = Extract<
-  E,
-  { path: P; method: M }
->['requestInput'];
+export type ApiInput<
+  E extends ApiEndpoints,
+  P extends E["path"],
+  M extends E["method"]
+> = Extract<E, { path: P; method: M }>["requestInput"];
 
 /**
  * Extracts the requestOutput type from an API endpoint definition
@@ -20,10 +21,11 @@ export type ApiInput<E extends ApiEndpoints, P extends E['path'], M extends E['m
  * @template P - Path string literal type (e.g. 'payments/account')
  * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
  */
-export type ApiOutput<E extends ApiEndpoints, P extends E['path'], M extends E['method']> = Extract<
-  E,
-  { path: P; method: M }
->['requestOutput'];
+export type ApiOutput<
+  E extends ApiEndpoints,
+  P extends E["path"],
+  M extends E["method"]
+> = Extract<E, { path: P; method: M }>["requestOutput"];
 
 /**
  * Extracts the response type from an API endpoint definition
@@ -31,10 +33,11 @@ export type ApiOutput<E extends ApiEndpoints, P extends E['path'], M extends E['
  * @template P - Path string literal type (e.g. 'payments/account')
  * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
  */
-export type ApiResponse<E extends ApiEndpoints, P extends E['path'], M extends E['method']> = Extract<
-  E,
-  { path: P; method: M }
->['response'];
+export type ApiResponse<
+  E extends ApiEndpoints,
+  P extends E["path"],
+  M extends E["method"]
+> = Extract<E, { path: P; method: M }>["response"];
 
 /**
  * Extracts the sucessful body type from an API endpoint definition
@@ -42,10 +45,14 @@ export type ApiResponse<E extends ApiEndpoints, P extends E['path'], M extends E
  * @template P - Path string literal type (e.g. 'payments/account')
  * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
  */
-export type ApiSuccessBody<E extends ApiEndpoints, P extends E['path'], M extends E['method']> = Extract<
-  Extract<E, { path: P; method: M }>['response'],
+export type ApiSuccessBody<
+  E extends ApiEndpoints,
+  P extends E["path"],
+  M extends E["method"]
+> = Extract<
+  Extract<E, { path: P; method: M }>["response"],
   { status: SuccessCode }
->['json'] extends () => Promise<infer R>
+>["json"] extends () => Promise<infer R>
   ? R
   : unknown;
 
@@ -55,40 +62,59 @@ export type ApiSuccessBody<E extends ApiEndpoints, P extends E['path'], M extend
  * @template P - Path string literal type (e.g. 'payments/account')
  * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
  */
-export type ApiErrorBody<E extends ApiEndpoints, P extends E['path'], M extends E['method']> = Extract<
-  Extract<E, { path: P; method: M }>['response'],
+export type ApiErrorBody<
+  E extends ApiEndpoints,
+  P extends E["path"],
+  M extends E["method"]
+> = Extract<
+  Extract<E, { path: P; method: M }>["response"],
   { status: ErrorCode }
->['json'] extends () => Promise<infer R>
+>["json"] extends () => Promise<infer R>
   ? R
   : unknown;
 
 /**
  * Converts a RawApiGatewayHandler response type to a fetch like response type.
  */
-type ConvertToFetch<T> = T extends { statusCode: number; body: object; headers: object }
+type ConvertToFetch<T> = T extends {
+  statusCode: number;
+  body: object;
+  headers: object;
+}
   ? {
-      ok: T['statusCode'] extends SuccessCode ? true : false;
-      json: () => Promise<T['body']>;
-      status: T['statusCode'];
+      ok: T["statusCode"] extends SuccessCode ? true : false;
+      json: () => Promise<T["body"]>;
+      status: T["statusCode"];
     }
   : T;
 
-export type CleanResponse = Omit<Response, 'status' | 'ok' | 'json'>;
-export type FetchResponse<T extends (...args: any) => any> = ConvertToFetch<Awaited<ReturnType<T>>> & CleanResponse;
+export type CleanResponse = Omit<Response, "status" | "ok" | "json">;
+export type FetchResponse<T extends (...args: any) => any> = ConvertToFetch<
+  Awaited<ReturnType<T>>
+> &
+  CleanResponse;
 
 // ------------------------ Proper types ------------------
 // This is used by createApiRequest and createFormFunction
 
-export const HTTPMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'] as const;
+export const HTTPMethods = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS",
+  "HEAD",
+] as const;
 export type HTTPMethod = (typeof HTTPMethods)[number];
 
 export type ApiEndpoints = {
   path: string;
   method: HTTPMethod;
-  requestInput: Record<string, any>;
-  requestOutput: object;
+  requestInput: Record<string, any> | null;
+  requestOutput: object | null;
   response: FetchResponse<
-    // This means we get better types in the createFormFunction
+    // This means we get better types
     () => Promise<
       | {
           headers: object;

package/src/lambda/client.ts

@@ -1,4 +1,5 @@
-import { deserialize } from './deserializer.js';
+// import { deserialize } from './deserializer.js';
+import { parse } from 'devalue';
 import * as v from 'valibot';
 import type { ApiEndpoints, ApiInput, ApiResponse } from './client-types.js';
 
@@ -50,8 +51,12 @@ async function _apiRequest<T = Response>(
     credentials: 'include'
   });
 
+  let retrieved: Promise<string> | false = false;
   response.json = async () => {
-    return await deserialize(await response.text(), environment);
+    if (retrieved === false) {
+      retrieved = response.text();
+    }
+    return await parse(await retrieved);
   };
   return response as unknown as T;
 }

package/src/lambda/errors.ts

@@ -7,52 +7,52 @@
  * Im not sure it this is optimal behaviour and if not we will migrate to only using the errorResponse function
  */
 
-export const badRequestError = (message: string, fieldName?: string, fieldValue?: string) => ({
-  type: 'BadRequest' as const,
+export const error_lambda_badRequest = (message: string, fieldName?: string, fieldValue?: string) => ({
+  type: 'lambda_badRequest' as const,
   message,
   fieldName,
   fieldValue
 });
-export const unauthorizedError = (message: string) => ({
-  type: 'Unauthorized' as const,
+export const error_lambda_unauthorized = (message: string) => ({
+  type: 'lambda_unauthorized' as const,
   message
 });
 
-export const forbiddenError = (message: string) => ({
-  type: 'Forbidden' as const,
+export const error_lambda_forbidden = (message: string) => ({
+  type: 'lambda_forbidden' as const,
   message
 });
 
-export const notFoundError = (message: string, fieldName?: string, fieldValue?: string) => ({
-  type: 'NotFound' as const,
+export const error_lambda_notFound = (message: string, fieldName?: string, fieldValue?: string) => ({
+  type: 'lambda_notFound' as const,
   message,
   fieldName,
   fieldValue
 });
 
-export const conflictError = (message: string, fieldName?: string, fieldValue?: string) => ({
-  type: 'Conflict' as const,
+export const error_lambda_conflict = (message: string, fieldName?: string, fieldValue?: string) => ({
+  type: 'lambda_conflict' as const,
   message,
   fieldName,
   fieldValue
 });
 
-export const internalServerError = (message: string) => ({
-  type: 'InternalServerError' as const,
+export const error_lambda_internal = (message: string) => ({
+  type: 'lambda_internal' as const,
   message
 });
 
-export type BadRequestError = ReturnType<typeof badRequestError>;
-export type UnauthorizedError = ReturnType<typeof unauthorizedError>;
-export type ForbiddenError = ReturnType<typeof forbiddenError>;
-export type NotFoundError = ReturnType<typeof notFoundError>;
-export type ConflictError = ReturnType<typeof conflictError>;
-export type InternalServerError = ReturnType<typeof internalServerError>;
+export type type_error_lambda_badRequest = ReturnType<typeof error_lambda_badRequest>;
+export type type_error_lambda_unauthorized = ReturnType<typeof error_lambda_unauthorized>;
+export type type_error_lambda_forbidden = ReturnType<typeof error_lambda_forbidden>;
+export type type_error_lambda_notFound = ReturnType<typeof error_lambda_notFound>;
+export type type_error_lambda_conflict = ReturnType<typeof error_lambda_conflict>;
+export type type_error_lambda_internal = ReturnType<typeof error_lambda_internal>;
 
-export type LambdaError =
-  | BadRequestError
-  | UnauthorizedError
-  | ForbiddenError
-  | NotFoundError
-  | ConflictError
-  | InternalServerError;
+export type type_error_lambda =
+  | type_error_lambda_badRequest
+  | type_error_lambda_unauthorized
+  | type_error_lambda_forbidden
+  | type_error_lambda_notFound
+  | type_error_lambda_conflict
+  | type_error_lambda_internal;

package/src/lambda/handlerUtils.ts

@@ -1,5 +1,6 @@
 import type { APIGatewayProxyResultV2, Context } from 'aws-lambda';
-import { stringify } from './serializer.js';
+// import { stringify } from './serializer.js';
+import { stringify } from 'devalue';
 
 export type SuccessCode = 200 | 201 | 204;
 export type ErrorCode = 400 | 401 | 403 | 404 | 409 | 500;
@@ -12,32 +13,36 @@ export type ErrorBody = {
   };
 };
 
+/**
+ * The error response for the lambda functions to return
+ */
+export type ErrorRawProxyResultV2 = {
+  statusCode: ErrorCode;
+  headers?:
+    | {
+        [header: string]: boolean | number | string;
+      }
+    | undefined;
+  body?: ErrorBody;
+  isBase64Encoded?: boolean | undefined;
+  cookies?: string[] | undefined;
+};
+
+export type OkRawProxyResultV2 = {
+  statusCode: SuccessCode;
+  headers?:
+    | {
+        [header: string]: boolean | number | string;
+      }
+    | undefined;
+  body?: object | undefined;
+  isBase64Encoded?: boolean | undefined;
+  cookies?: string[] | undefined;
+};
 /**
  * A type for the raw proxy result - just using an object not a stirng for the body
  */
-export type RawProxyResultV2 =
-  | {
-      statusCode: ErrorCode;
-      headers?:
-        | {
-            [header: string]: boolean | number | string;
-          }
-        | undefined;
-      body?: ErrorBody;
-      isBase64Encoded?: boolean | undefined;
-      cookies?: string[] | undefined;
-    }
-  | {
-      statusCode: SuccessCode;
-      headers?:
-        | {
-            [header: string]: boolean | number | string;
-          }
-        | undefined;
-      body?: object | undefined;
-      isBase64Encoded?: boolean | undefined;
-      cookies?: string[] | undefined;
-    };
+export type RawProxyResultV2 = ErrorRawProxyResultV2 | OkRawProxyResultV2;
 
 // The type of the handler returned from wrapHandler
 export type APIGatewayHandler<E> = (event: E, context: Context) => Promise<APIGatewayProxyResultV2>;
@@ -64,7 +69,7 @@ export function wrapHandler<E>(handler: RawApiGatewayHandler<E>): APIGatewayHand
     const result = await handler(event, context);
     return {
       ...result,
-      body: result.body ? await stringify(result.body) : undefined
+      body: result.body ? stringify(result.body) : undefined
     };
   };
 }

package/src/lambda/index.ts

@@ -1,3 +1,6 @@
 export * from './browser.js';
 export * from './errors.js';
 export * from './response.js';
+
+// Server
+export * from './server/authentication.js';

package/src/lambda/response.ts

@@ -1,5 +1,6 @@
-import type { SafeParseResult } from 'valibot';
-import { badRequestError, type LambdaError } from './errors.js';
+import type { BaseIssue, SafeParseResult } from 'valibot';
+import { error_lambda_badRequest, type type_error_lambda } from './errors.js';
+import type { ErrorRawProxyResultV2, OkRawProxyResultV2 } from './handlerUtils.js';
 
 function field(obj: { fieldName?: string; fieldValue?: string }) {
   return obj.fieldName === undefined || obj.fieldValue === undefined
@@ -12,60 +13,104 @@ function field(obj: { fieldName?: string; fieldValue?: string }) {
       };
 }
 
-/**
- * Takes a lambda error and gives an error response suitable to be returned from the lambda handler
- */
-export function errorResponse(e: LambdaError, headers: any) {
+export type type_error_response = Omit<ErrorRawProxyResultV2, 'headers' | 'body'> & {
+  headers: NonNullable<ErrorRawProxyResultV2['headers']>;
+  body: NonNullable<ErrorRawProxyResultV2['body']>;
+};
+
+export type LambdaErrorResponse<Type extends string = '', Extras extends object | never = never> =
+  | {
+      headers: Record<string, string>;
+      statusCode: 400;
+      body: { message: string; type: Type } & ReturnType<typeof field> & Extras;
+    }
+  | { headers: Record<string, string>; statusCode: 401; body: { message: string; type: Type } & Extras }
+  | { headers: Record<string, string>; statusCode: 403; body: { message: string; type: Type } & Extras }
+  | {
+      headers: Record<string, string>;
+      statusCode: 404;
+      body: { message: string; type: Type } & ReturnType<typeof field> & Extras;
+    }
+  | {
+      headers: Record<string, string>;
+      statusCode: 409;
+      body: { message: string; type: Type } & ReturnType<typeof field> & Extras;
+    }
+  | { headers: Record<string, string>; statusCode: 500; body: { message: string; type: Type } & Extras };
+
+export function response_error<Type extends string, Extras extends object | never = never>(
+  e: type_error_lambda,
+  headers: Record<string, string>,
+  type: Type = '' as Type,
+  extras: Extras = {} as Extras
+): LambdaErrorResponse<Type, Extras> {
   switch (e.type) {
-    case 'BadRequest':
+    case 'lambda_badRequest':
       return {
         headers,
-        statusCode: 400 as const,
+        statusCode: 400,
         body: {
           message: e.message,
-          ...field(e)
+          type: type,
+          ...field(e),
+          ...extras
         }
       };
-    case 'Unauthorized':
+
+    case 'lambda_unauthorized':
       return {
         headers,
-        statusCode: 401 as const,
+        statusCode: 401,
         body: {
-          message: e.message
+          message: e.message,
+          type: type,
+          ...extras
         }
       };
-    case 'Forbidden':
+
+    case 'lambda_forbidden':
       return {
         headers,
-        statusCode: 403 as const,
+        statusCode: 403,
         body: {
-          message: e.message
+          message: e.message,
+          type: type,
+          ...extras
         }
       };
-    case 'NotFound':
+
+    case 'lambda_notFound':
       return {
         headers,
-        statusCode: 404 as const,
+        statusCode: 404,
         body: {
           message: e.message,
-          ...field(e)
+          type: type,
+          ...field(e),
+          ...extras
         }
       };
-    case 'Conflict':
+
+    case 'lambda_conflict':
       return {
         headers,
-        statusCode: 409 as const,
+        statusCode: 409,
         body: {
           message: e.message,
-          ...field(e)
+          type: type,
+          ...field(e),
+          ...extras
         }
       };
+
     default:
       return {
         headers,
-        statusCode: 500 as const,
+        statusCode: 500,
         body: {
-          message: 'Unknown error'
+          message: 'Unknown error',
+          type: type,
+          ...extras
         }
       };
   }
@@ -73,9 +118,28 @@ export function errorResponse(e: LambdaError, headers: any) {
 
 /**
  * Helper function to get a reasonable default error response from a valibot parse result
+ * @param res - The output from calling safeParse on the input
+ * @param headers - The headers to return in the response
  */
-export function valibotErrorResponse(res: Extract<SafeParseResult<any>, { success: false }>, headers: any) {
-  const issue = res.issues[0];
+export function response_valibotError(res: Extract<SafeParseResult<any>, { success: false }>, headers: any) {
+  const issue = res.issues[0] as BaseIssue<any>;
+
+  if (issue.path && issue.path[0] && typeof issue.path[0].key === 'string') {
+    return response_error(error_lambda_badRequest('Invalid input', issue.path[0].key, issue.message), headers);
+  } else {
+    return response_error(error_lambda_badRequest(`Invalid input: ${issue.message}`), headers);
+  }
+}
 
-  return errorResponse(badRequestError('Invalid parameters', issue.path[0].key, issue.message), headers);
+export function response_ok<Body extends { message: string }>(
+  body: Body,
+  headers: any,
+  cookies?: string[] | undefined
+) {
+  return {
+    headers,
+    cookies,
+    statusCode: 200 as const,
+    body
+  } satisfies OkRawProxyResultV2;
 }

package/src/lambda/server/authentication.ts

@@ -0,0 +1,32 @@
+import type { APIGatewayProxyEventV2WithLambdaAuthorizer, APIGatewayRequestAuthorizerEventV2 } from 'aws-lambda';
+import { Result } from 'neverthrow';
+import { parse } from 'cookie';
+import { error_lambda_unauthorized } from '$lambda/errors.js';
+
+/**
+ * Wraps cookies parse along with the api gateway event with neverthrow
+ */
+export const getCookies = Result.fromThrowable(
+  (event: APIGatewayProxyEventV2WithLambdaAuthorizer<any> | APIGatewayRequestAuthorizerEventV2) => {
+    if (!('headers' in event) || !event.headers) {
+      throw new Error('No headers in event');
+    }
+
+    // First try to get cookies from the cookies array (API Gateway v2 format)
+    const cookieString =
+      Array.isArray(event.cookies) && event.cookies.length > 0
+        ? event.cookies.join('; ')
+        : event.headers.Cookie || event.headers.cookie;
+
+    if (!cookieString) {
+      throw new Error('No cookies found in event');
+    }
+
+    const res = parse(cookieString);
+    return res;
+  },
+  (e) => {
+    if (e instanceof Error) return error_lambda_unauthorized(e.message);
+    return error_lambda_unauthorized('Invalid Cookies');
+  }
+);

package/src/s3/client.ts

@@ -0,0 +1,8 @@
+import { S3Client } from '@aws-sdk/client-s3';
+
+/**
+ * Convenience function for S3Client when process.env.REGION is set
+ */
+export function getS3() {
+  return new S3Client({ endpoint: `https://s3.${process.env.REGION}.amazonaws.com`, region: process.env.REGION });
+}

package/src/s3/errors.ts

@@ -0,0 +1,6 @@
+export const error_s3_internal = {
+  type: 's3_internal' as const
+};
+export const error_s3_get = {
+  type: 's3_get' as const
+};

package/src/s3/index.ts

@@ -0,0 +1,6 @@
+export * from './client.js';
+
+export * from './errors.js';
+
+export * from './signedUrl.js';
+export * from './object.js';

package/src/s3/object.ts

@@ -0,0 +1,37 @@
+import { ResultAsync } from 'neverthrow';
+import { getS3 } from './client.js';
+import { GetObjectCommand } from '@aws-sdk/client-s3';
+import { error_s3_get } from './errors.js';
+
+/**
+ * Retrieves an object from an S3 bucket.
+ *
+ * @param {string} bucketName - The name of the S3 bucket.
+ * @param {string} key - The key of the object to retrieve.
+ * @returns {Promise<Buffer>} A promise that resolves to the object data as a Buffer.
+ */
+export const getObject = ResultAsync.fromThrowable(
+  async (bucketName: string, key: string) => {
+    const s3 = getS3();
+    const cmd = new GetObjectCommand({ Bucket: bucketName, Key: key });
+    const res = await s3.send(cmd);
+    const stream = res.Body as any;
+    return new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      stream.on('data', (chunk: Buffer) => chunks.push(chunk));
+      stream.on('end', () => resolve(Buffer.concat(chunks)));
+      stream.on('error', reject);
+    });
+  },
+  (e) => {
+    console.error(`Error getting object from S3: ${e}`);
+    return error_s3_get;
+  }
+);
+
+/**
+ * Convenience function to get an object from S3 and return it as a string.
+ */
+export function getObjectString(bucketName: string, key: string): ResultAsync<string, typeof error_s3_get> {
+  return getObject(bucketName, key).map((buffer) => buffer.toString('utf-8'));
+}

package/src/s3/signedUrl.ts

@@ -0,0 +1,4 @@
+import { ResultAsync } from 'neverthrow';
+import { getSignedUrl as baseGetSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+export const getSignedUrl = ResultAsync.fromThrowable(baseGetSignedUrl, (e) => e);