chore: update .prettierrc to use double quotes instead of single quotes

Author: c-c-epr

.github/dependabot.yaml

@@ -1,10 +1,10 @@
 version: 2
 updates:
-  - package-ecosystem: 'npm'
-    directory: '/'
+  - package-ecosystem: "npm"
+    directory: "/"
     schedule:
-      interval: 'daily'
-  - package-ecosystem: 'github-actions'
-    directory: '/'
+      interval: "daily"
+  - package-ecosystem: "github-actions"
+    directory: "/"
     schedule:
-      interval: 'daily'
+      interval: "daily"

.prettierrc

@@ -1,6 +1,6 @@
 {
   "printWidth": 140,
-  "singleQuote": true,
+  "singleQuote": false,
   "semi": true,
   "useTabs": false,
   "tabWidth": 2

src/_index.ts

@@ -1,4 +1,4 @@
-import { router } from './router';
+import { router } from "./router";
 
 export default {
   async fetch(request, env, ctx): Promise<Response> {

src/router.ts

@@ -1,47 +1,47 @@
-import crypto from 'crypto';
+import crypto from "crypto";
 
 export async function router(request: Request, env: Env, ctx: ExecutionContext) {
-  if (request.method !== 'POST') {
-    return new Response('Method Not Allowed', { status: 405 });
+  if (request.method !== "POST") {
+    return new Response("Method Not Allowed", { status: 405 });
   }
 
   //////////////////////////////////////////////
   //此段應該在 Zeabur 修復 Bug 後移除
-  console.log(request.headers.get('X-ZSend-Event'));
-  if (request.headers.get('X-ZSend-Event') === 'test') {
-    return new Response('OK!');
+  console.log(request.headers.get("X-ZSend-Event"));
+  if (request.headers.get("X-ZSend-Event") === "test") {
+    return new Response("OK!");
   }
   //////////////////////////////////////////////
 
   const secret = env.SECRET_KEY;
   if (!secret) {
-    return new Response('Server configuration error: SECRET_KEY is not set', { status: 500 });
+    return new Response("Server configuration error: SECRET_KEY is not set", { status: 500 });
   }
 
-  const signature = request.headers.get('x-zsend-signature') as string | null;
-  const timestamp = request.headers.get('x-zsend-timestamp') as string | null;
+  const signature = request.headers.get("x-zsend-signature") as string | null;
+  const timestamp = request.headers.get("x-zsend-timestamp") as string | null;
 
   if (!signature || !timestamp) {
-    return new Response('Missing signature or timestamp', { status: 400 });
+    return new Response("Missing signature or timestamp", { status: 400 });
   }
 
   let body = {};
-  let rawBody = '';
+  let rawBody = "";
 
   try {
     const clone = request.clone();
     body = await clone.json();
     rawBody = await request.text();
   } catch (e) {
-    console.error('Failed JSON', { error: e, rawBody });
-    return new Response('Invalid JSON', { status: 400 });
+    console.error("Failed JSON", { error: e, rawBody });
+    return new Response("Invalid JSON", { status: 400 });
   }
 
   const message = `${timestamp}.${rawBody}`;
-  const expectedSignature = crypto.createHmac('sha256', secret).update(message).digest('hex');
+  const expectedSignature = crypto.createHmac("sha256", secret).update(message).digest("hex");
 
   if (signature !== `sha256=${expectedSignature}`) {
-    return new Response('Invalid signature', { status: 401 });
+    return new Response("Invalid signature", { status: 401 });
   }
 
   // 非同步執行
@@ -51,5 +51,5 @@ export async function router(request: Request, env: Env, ctx: ExecutionContext)
     })(),
   );
   //  回傳成功
-  return new Response('OK!');
+  return new Response("OK!");
 }

test/constants.ts

@@ -1 +1 @@
-export const TEST_SECRET_KEY = 'test-secret-key';
+export const TEST_SECRET_KEY = "test-secret-key";

test/env.d.ts

@@ -1,3 +1,3 @@
-declare module 'cloudflare:test' {
+declare module "cloudflare:test" {
   interface ProvidedEnv extends Env {}
 }

test/index.spec.ts

@@ -1,106 +1,106 @@
-import { env, createExecutionContext, waitOnExecutionContext, SELF } from 'cloudflare:test';
-import { describe, it, expect } from 'vitest';
-import crypto from 'crypto';
-import worker from '../src/_index';
-import { TEST_SECRET_KEY } from './constants';
+import { env, createExecutionContext, waitOnExecutionContext, SELF } from "cloudflare:test";
+import { describe, it, expect } from "vitest";
+import crypto from "crypto";
+import worker from "../src/_index";
+import { TEST_SECRET_KEY } from "./constants";
 
 const IncomingRequest = Request<unknown, IncomingRequestCfProperties>;
 
-const timestamp = '1710000000';
-const payload = { id: 'evt_123', status: 'paid' };
+const timestamp = "1710000000";
+const payload = { id: "evt_123", status: "paid" };
 const rawBody = JSON.stringify(payload);
 
 function signatureFor(secret: string, body = rawBody) {
-  const digest = crypto.createHmac('sha256', secret).update(`${timestamp}.${body}`).digest('hex');
+  const digest = crypto.createHmac("sha256", secret).update(`${timestamp}.${body}`).digest("hex");
   return `sha256=${digest}`;
 }
 
 function signedRequest(body = rawBody, signature = signatureFor(TEST_SECRET_KEY, body)) {
-  return new IncomingRequest('http://example.com/webhook', {
-    method: 'POST',
+  return new IncomingRequest("http://example.com/webhook", {
+    method: "POST",
     headers: {
-      'content-type': 'application/json',
-      'x-zsend-event': 'payment.succeeded',
-      'x-zsend-signature': signature,
-      'x-zsend-timestamp': timestamp,
+      "content-type": "application/json",
+      "x-zsend-event": "payment.succeeded",
+      "x-zsend-signature": signature,
+      "x-zsend-timestamp": timestamp,
     },
     body,
   });
 }
 
-describe('ZSend webhook worker', () => {
-  it('rejects non-POST requests', async () => {
-    const request = new IncomingRequest('http://example.com/webhook');
+describe("ZSend webhook worker", () => {
+  it("rejects non-POST requests", async () => {
+    const request = new IncomingRequest("http://example.com/webhook");
     const ctx = createExecutionContext();
     const response = await worker.fetch(request, env, ctx);
     await waitOnExecutionContext(ctx);
 
     expect(response.status).toBe(405);
-    expect(await response.text()).toBe('Method Not Allowed');
+    expect(await response.text()).toBe("Method Not Allowed");
   });
 
-  it('rejects requests when SECRET_KEY is not configured', async () => {
+  it("rejects requests when SECRET_KEY is not configured", async () => {
     const request = signedRequest();
     const ctx = createExecutionContext();
-    const response = await worker.fetch(request, { ...env, SECRET_KEY: '' }, ctx);
+    const response = await worker.fetch(request, { ...env, SECRET_KEY: "" }, ctx);
     await waitOnExecutionContext(ctx);
 
     expect(response.status).toBe(500);
-    expect(await response.text()).toBe('Server configuration error: SECRET_KEY is not set');
+    expect(await response.text()).toBe("Server configuration error: SECRET_KEY is not set");
   });
 
-  it('rejects requests missing signature headers', async () => {
-    const request = new IncomingRequest('http://example.com/webhook', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
+  it("rejects requests missing signature headers", async () => {
+    const request = new IncomingRequest("http://example.com/webhook", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
       body: rawBody,
     });
     const ctx = createExecutionContext();
     const response = await worker.fetch(request, env, ctx);
     await waitOnExecutionContext(ctx);
 
     expect(response.status).toBe(400);
-    expect(await response.text()).toBe('Missing signature or timestamp');
+    expect(await response.text()).toBe("Missing signature or timestamp");
   });
 
-  it('rejects invalid JSON bodies', async () => {
-    const request = signedRequest('{bad json}', signatureFor(TEST_SECRET_KEY, '{bad json}'));
+  it("rejects invalid JSON bodies", async () => {
+    const request = signedRequest("{bad json}", signatureFor(TEST_SECRET_KEY, "{bad json}"));
     const ctx = createExecutionContext();
     const response = await worker.fetch(request, env, ctx);
     await waitOnExecutionContext(ctx);
 
     expect(response.status).toBe(400);
-    expect(await response.text()).toBe('Invalid JSON');
+    expect(await response.text()).toBe("Invalid JSON");
   });
 
-  it('rejects requests with invalid signatures', async () => {
-    const request = signedRequest(rawBody, 'invalid-signature');
+  it("rejects requests with invalid signatures", async () => {
+    const request = signedRequest(rawBody, "invalid-signature");
     const ctx = createExecutionContext();
     const response = await worker.fetch(request, env, ctx);
     await waitOnExecutionContext(ctx);
 
     expect(response.status).toBe(401);
-    expect(await response.text()).toBe('Invalid signature');
+    expect(await response.text()).toBe("Invalid signature");
   });
 
-  it('accepts valid signed webhook requests in unit style', async () => {
+  it("accepts valid signed webhook requests in unit style", async () => {
     const request = signedRequest();
     const ctx = createExecutionContext();
     const response = await worker.fetch(request, env, ctx);
     await waitOnExecutionContext(ctx);
 
     expect(response.status).toBe(200);
-    expect(await response.text()).toBe('OK!');
+    expect(await response.text()).toBe("OK!");
   });
 
-  it('accepts valid signed webhook requests in integration style', async () => {
-    const response = await SELF.fetch('https://example.com/webhook', {
-      method: 'POST',
+  it("accepts valid signed webhook requests in integration style", async () => {
+    const response = await SELF.fetch("https://example.com/webhook", {
+      method: "POST",
       headers: signedRequest().headers,
       body: rawBody,
     });
 
     expect(response.status).toBe(200);
-    expect(await response.text()).toBe('OK!');
+    expect(await response.text()).toBe("OK!");
   });
 });

vitest.config.mts

@@ -1,13 +1,13 @@
-import { cloudflareTest } from '@cloudflare/vitest-pool-workers';
-import { defineConfig } from 'vitest/config';
-import { TEST_SECRET_KEY } from './test/constants';
+import { cloudflareTest } from "@cloudflare/vitest-pool-workers";
+import { defineConfig } from "vitest/config";
+import { TEST_SECRET_KEY } from "./test/constants";
 
 process.env.SECRET_KEY ??= TEST_SECRET_KEY;
 
 export default defineConfig({
   plugins: [
     cloudflareTest({
-      wrangler: { configPath: './wrangler.jsonc' },
+      wrangler: { configPath: "./wrangler.jsonc" },
       miniflare: {
         bindings: {
           SECRET_KEY: TEST_SECRET_KEY,