@webamoki/web-svelte 0.7.2 → 0.7.4

package/dist/server/form-handler.js

@@ -1,14 +1,13 @@
-import { DatabaseError } from 'pg';
 import { fail, message as superFormMessage } from 'sveltekit-superforms';
 /**
  * automatically handle database errors from catch.
  * used in form/action handling in page.server.ts
  */
 export function handleDbErrorForm(form, message, err) {
-    if (err instanceof DatabaseError) {
-        console.error(`Database Error ${message}:`, err);
-        return fail(500, { form });
-    }
+    // if (err instanceof DatabaseError) {
+    // 	console.error(`Database Error ${message}:`, err);
+    // 	return fail(500, { form });
+    // }
     console.error(`Unexpected Error ${message}:`, err);
     return fail(500, { form });
 }
@@ -16,7 +15,9 @@ export function handleDbErrorForm(form, message, err) {
  * check if an error returned by a try catch is a duplicate value error in postgre
  */
 export function isDuplicateDbError(err) {
-    return err instanceof DatabaseError && err.code === '23505';
+    console.error('Checking for duplicate error:', err);
+    console.error('Error type:', err instanceof Error ? err.name : typeof err);
+    return false;
 }
 export function successMessage(form, options) {
     const message = {

package/dist/utils/email/README.md

@@ -1,10 +1,20 @@
 # Email Utility Package
 
-This package provides utilities for sending emails using AWS Simple Email Service (SES).
+This package provides utilities for sending emails using AWS Simple Email Service (SES) API.
+
+## Key Features
+
+- **Cloudflare Workers Compatible**: Uses direct AWS SES API calls with fetch instead of AWS SDK
+- **AWS Signature V4**: Implements proper AWS authentication for secure API requests
+- **Zero Heavy Dependencies**: No AWS SDK required, works in any JavaScript runtime with fetch support
 
 ## Installation
 
-The AWS SES SDK is already included as a dependency. You'll need to configure your AWS credentials and region.
+No additional dependencies required beyond the standard JavaScript runtime. The implementation uses:
+
+- Native `fetch` API for HTTP requests
+- Web Crypto API for AWS Signature V4 signing
+- Native `DOMParser` for XML response parsing
 
 ## Configuration
 

package/dist/utils/email/aws-signer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * AWS Signature Version 4 signing utilities for SES API
+ * Compatible with Cloudflare Workers and other edge runtimes
+ */
+interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+}
+/**
+ * Create AWS Signature V4 authorization header
+ */
+export declare function signRequest(method: string, host: string, path: string, body: string, credentials: AwsCredentials, service?: string): Promise<{
+    headers: Record<string, string>;
+    signedHeaders: string;
+}>;
+export {};

package/dist/utils/email/aws-signer.js

@@ -0,0 +1,83 @@
+/**
+ * AWS Signature Version 4 signing utilities for SES API
+ * Compatible with Cloudflare Workers and other edge runtimes
+ */
+/**
+ * Create a SHA-256 hash
+ */
+async function sha256(message) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(message);
+    return await crypto.subtle.digest('SHA-256', data);
+}
+/**
+ * Create a SHA-256 HMAC
+ */
+async function hmacSha256(key, message) {
+    const encoder = new TextEncoder();
+    const keyData = key instanceof ArrayBuffer ? new Uint8Array(key) : key;
+    const cryptoKey = await crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    return await crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(message));
+}
+/**
+ * Convert ArrayBuffer to hex string
+ */
+function bufferToHex(buffer) {
+    return Array.from(new Uint8Array(buffer))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * Get signing key for AWS Signature V4
+ */
+async function getSignatureKey(key, dateStamp, regionName, serviceName) {
+    const encoder = new TextEncoder();
+    const kDate = await hmacSha256(encoder.encode('AWS4' + key), dateStamp);
+    const kRegion = await hmacSha256(kDate, regionName);
+    const kService = await hmacSha256(kRegion, serviceName);
+    const kSigning = await hmacSha256(kService, 'aws4_request');
+    return kSigning;
+}
+/**
+ * Create AWS Signature V4 authorization header
+ */
+export async function signRequest(method, host, path, body, credentials, service = 'ses') {
+    const { accessKeyId, secretAccessKey, region } = credentials;
+    // Create timestamp
+    const now = new Date();
+    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, ''); // Format: YYYYMMDDTHHMMSSZ
+    const dateStamp = amzDate.slice(0, 8); // Format: YYYYMMDD
+    // Hash the request body
+    const payloadHash = bufferToHex(await sha256(body));
+    // Create canonical headers
+    const canonicalHeaders = `host:${host}\n` + `x-amz-date:${amzDate}\n`;
+    const signedHeaders = 'host;x-amz-date';
+    // Create canonical request
+    const canonicalRequest = `${method}\n` +
+        `${path}\n` +
+        `\n` + // Empty query string
+        `${canonicalHeaders}\n` +
+        `${signedHeaders}\n` +
+        `${payloadHash}`;
+    // Create string to sign
+    const algorithm = 'AWS4-HMAC-SHA256';
+    const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+    const canonicalRequestHash = bufferToHex(await sha256(canonicalRequest));
+    const stringToSign = `${algorithm}\n` + `${amzDate}\n` + `${credentialScope}\n` + `${canonicalRequestHash}`;
+    // Calculate signature
+    const signingKey = await getSignatureKey(secretAccessKey, dateStamp, region, service);
+    const signature = bufferToHex(await hmacSha256(signingKey, stringToSign));
+    // Create authorization header
+    const authorizationHeader = `${algorithm} ` +
+        `Credential=${accessKeyId}/${credentialScope}, ` +
+        `SignedHeaders=${signedHeaders}, ` +
+        `Signature=${signature}`;
+    return {
+        headers: {
+            Authorization: authorizationHeader,
+            'X-Amz-Date': amzDate,
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        signedHeaders
+    };
+}

package/dist/utils/email/ses.d.ts

@@ -10,7 +10,8 @@ export interface SendEmailOptions {
     replyTo?: string | string[];
 }
 /**
- * Send an email using AWS SES.
+ * Send an email using AWS SES API.
+ * Uses AWS Signature V4 signing and fetch API for Cloudflare Workers compatibility.
  *
  * Environment variables required:
  * - AWS_REGION

package/dist/utils/email/ses.js

@@ -1,8 +1,7 @@
-import { SESClient, SendEmailCommand } from '@aws-sdk/client-ses';
-// Create SES client once at module level for reuse across function calls
-const sesClient = new SESClient({ region: process.env.AWS_REGION });
+import { signRequest } from './aws-signer.js';
 /**
- * Send an email using AWS SES.
+ * Send an email using AWS SES API.
+ * Uses AWS Signature V4 signing and fetch API for Cloudflare Workers compatibility.
  *
  * Environment variables required:
  * - AWS_REGION
@@ -39,48 +38,102 @@ export async function sendEmail(options) {
     if (!toAddresses || toAddresses.length === 0) {
         throw new Error('sendEmail: at least one valid recipient is required (to)');
     }
+    // Get AWS credentials from environment
+    const region = process.env.AWS_REGION;
+    const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+    if (!region || !accessKeyId || !secretAccessKey) {
+        throw new Error('sendEmail: missing required environment variables (AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)');
+    }
     // Format source with optional fromName
     const source = fromName ? `${fromName} <${from}>` : from;
-    // Build message body
-    const Message = {
-        Subject: {
-            Charset: 'UTF-8',
-            Data: subject
-        },
-        Body: {}
-    };
+    // Build form-encoded request body for SES API
+    const params = new URLSearchParams();
+    params.append('Action', 'SendEmail');
+    params.append('Source', source);
+    // Add destination addresses
+    toAddresses.forEach((addr, i) => params.append(`Destination.ToAddresses.member.${i + 1}`, addr));
+    if (ccAddresses) {
+        ccAddresses.forEach((addr, i) => params.append(`Destination.CcAddresses.member.${i + 1}`, addr));
+    }
+    if (bccAddresses) {
+        bccAddresses.forEach((addr, i) => params.append(`Destination.BccAddresses.member.${i + 1}`, addr));
+    }
+    // Add reply-to addresses
+    if (replyToAddresses) {
+        replyToAddresses.forEach((addr, i) => params.append(`ReplyToAddresses.member.${i + 1}`, addr));
+    }
+    // Add message subject
+    params.append('Message.Subject.Data', subject);
+    params.append('Message.Subject.Charset', 'UTF-8');
+    // Add message body
     if (html) {
-        Message.Body.Html = {
-            Charset: 'UTF-8',
-            Data: html
-        };
+        params.append('Message.Body.Html.Data', html);
+        params.append('Message.Body.Html.Charset', 'UTF-8');
     }
     if (text) {
-        Message.Body.Text = {
-            Charset: 'UTF-8',
-            Data: text
-        };
+        params.append('Message.Body.Text.Data', text);
+        params.append('Message.Body.Text.Charset', 'UTF-8');
     }
-    const params = {
-        Source: source,
-        Destination: {
-            ToAddresses: toAddresses,
-            CcAddresses: ccAddresses,
-            BccAddresses: bccAddresses
-        },
-        Message,
-        ReplyToAddresses: replyToAddresses
-    };
+    const body = params.toString();
+    const host = `email.${region}.amazonaws.com`;
+    const path = '/';
     try {
-        const command = new SendEmailCommand(params);
-        const res = await sesClient.send(command);
-        if (!res.MessageId) {
-            throw new Error('sendEmail: SES response did not contain a MessageId');
+        // Sign the request
+        const { headers } = await signRequest('POST', host, path, body, {
+            accessKeyId,
+            secretAccessKey,
+            region
+        });
+        // Make the API request
+        const response = await fetch(`https://${host}${path}`, {
+            method: 'POST',
+            headers: {
+                ...headers,
+                Host: host,
+                'Content-Length': body.length.toString()
+            },
+            body
+        });
+        const responseText = await response.text();
+        if (!response.ok) {
+            // Parse error response using regex (works in Node.js and browsers)
+            let errorMessage = 'Unknown error';
+            let errorCode;
+            try {
+                const codeMatch = responseText.match(/<Code>(.*?)<\/Code>/);
+                const messageMatch = responseText.match(/<Message>(.*?)<\/Message>/);
+                if (codeMatch)
+                    errorCode = codeMatch[1];
+                if (messageMatch)
+                    errorMessage = messageMatch[1];
+            }
+            catch {
+                errorMessage = responseText || `HTTP ${response.status} ${response.statusText}`;
+            }
+            throw new Error(`sendEmail: failed to send email: ${JSON.stringify({ message: errorMessage, code: errorCode })}`);
+        }
+        // Parse success response for MessageId using regex (works in Node.js and browsers)
+        try {
+            const messageIdMatch = responseText.match(/<MessageId>(.*?)<\/MessageId>/);
+            if (!messageIdMatch || !messageIdMatch[1]) {
+                throw new Error('sendEmail: SES response did not contain a MessageId');
+            }
+            return messageIdMatch[1];
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('MessageId')) {
+                throw err;
+            }
+            throw new Error(`sendEmail: failed to parse SES response: ${err instanceof Error ? err.message : String(err)}`);
         }
-        return res.MessageId;
     }
     catch (err) {
-        // Normalize error for callers
+        // Re-throw if already formatted
+        if (err instanceof Error && err.message.startsWith('sendEmail:')) {
+            throw err;
+        }
+        // Normalize other errors
         const message = err instanceof Error ? err.message : String(err);
         let code;
         if (err && typeof err === 'object') {
@@ -89,7 +142,6 @@ export async function sendEmail(options) {
                 code = e['name'];
         }
         const details = { message, code };
-        // Re-throw a clear error for the caller to handle
         throw new Error(`sendEmail: failed to send email: ${JSON.stringify(details)}`);
     }
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.2",
+  "version": "0.7.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -75,6 +75,7 @@
     "@changesets/cli": "^2.29.7",
     "@eslint/compat": "^1.4.1",
     "@eslint/js": "^9.39.1",
+    "@sveltejs/adapter-cloudflare": "^7.2.8",
     "@sveltejs/kit": "^2.48.4",
     "@sveltejs/package": "^2.5.4",
     "@sveltejs/vite-plugin-svelte": "^6.2.1",
@@ -82,7 +83,6 @@
     "@tailwindcss/typography": "^0.5.19",
     "@tailwindcss/vite": "^4.1.17",
     "@types/node": "^22.19.1",
-    "@types/pg": "^8.15.6",
     "@types/ramda": "^0.31.1",
     "@types/sorted-array-functions": "^1.3.3",
     "clsx": "^2.1.1",
@@ -110,7 +110,6 @@
     "svelte"
   ],
   "dependencies": {
-    "@aws-sdk/client-ses": "^3.948.0",
     "@internationalized/date": "^3.10.0",
     "@lucide/svelte": "^0.553.0",
     "@sveltejs/adapter-auto": "^7.0.0",
@@ -119,7 +118,6 @@
     "devalue": "^5.5.0",
     "drizzle-orm": "^0.44.7",
     "formsnap": "^2.0.1",
-    "pg": "^8.16.3",
     "ramda": "^0.31.3",
     "sorted-array-functions": "^1.3.0",
     "svelte-awesome-color-picker": "^4.1.0",