const response = await fetch(env.ENDPOINT, {
        method: "POST",
        headers: {
            Authorization: `Basic ${btoa(
                `someKey`
            )}]`,
            "Content-Type": "application/x-www-form-urlencoded"
        },
        body: "someBody"
    });

- name: Deploy API Service
        uses: cloudflare/wrangler-action@v3
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          command: publish --config wrangler.toml
          workingDirectory: apps/sso
          secrets: |
            AFDIAN_CLIENT_ID
            AFDIAN_CLIENT_SECRET
            AFDIAN_CALLBACK_URL
            ALIPAY_APP_ID
            ALIPAY_PRIVATE_KEY
            ALIPAY_CALLBACK_URL
            GITHUB_ID
            GITHUB_SECRET
            SESSION_SECRET
          # SESSION_KEY
          # GITHUB_CALLBACK_URL
        env:
          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CF_ACCOUNT_ID }}
          AFDIAN_CLIENT_ID: ${{ secrets.AFDIAN_CLIENT_ID }}
          AFDIAN_CLIENT_SECRET: ${{ secrets.AFDIAN_CLIENT_SECRET }}
          AFDIAN_CALLBACK_URL: ${{ secrets.AFDIAN_CALLBACK_URL }}
          ALIPAY_APP_ID: ${{ secrets.ALIPAY_APP_ID }}
          ALIPAY_PRIVATE_KEY: ${{ secrets.ALIPAY_PRIVATE_KEY }}
          ALIPAY_CALLBACK_URL: ${{ secrets.ALIPAY_CALLBACK_URL }}
          GITHUB_ID: ${{ secrets.GH_CLIENT_ID }}
          GITHUB_SECRET: ${{ secrets.GH_CLIENT_SECRET }}
          SESSION_SECRET: ${{ secrets.SESSION_SECRET }}
          # SESSION_KEY: ${{ secrets.SESSION_KEY }}
          # GITHUB_CALLBACK_URL: ${{ secrets.GITHUB_CALLBACK_URL }}

const corsHeaders = new Headers({
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
    'Access-Control-Allow-Headers': 'Authorization, Content-Type',
    'Content-Type': 'application/json',
});

js
const { results } = await env.DB.prepare('SELECT * FROM user').all();
const json = await Response.json(results);
const jjson = JSON.stringify(json);
console.log(jjson);

serialize-javascript

ts
    it('Must be able to create mock Request with cf user init', function() {
        const user  : IncomingRequestCfProperties = TestUsers.cfCambridgeUser       
        const init : RequestInit = {
            method: 'GET',
            cf: user
        };
        const newRequest = new Request('https://example.com', init);
        // Check if cf properties are set
        console.log(">>> newRequest.cf >>>" , newRequest.cf);
        assert.ok(newRequest.cf!==undefined)
    })

ts
interface RequestInit {
  method?: string;
  headers?: HeadersInit;
  body?: BodyInit | null;
  redirect?: string;
  fetcher?: Fetcher | null;
  /**
   * cf is a union of these two types because there are multiple
   * scenarios in which it might be one or the other.
   *
   * IncomingRequestCfProperties is required to allow
   *   new Request(someUrl, event.request)
   *
   * RequestInitCfProperties is required to allow
   *   new Request(event.request, {cf: { ... } })
   *   fetch(someUrl, {cf: { ... } })
   */
  cf?: IncomingRequestCfProperties | RequestInitCfProperties;
  signal?: AbortSignal | null;
}

*website.com/images*

ts
export interface Env {
    COUNTER: DurableObjectNamespace;
}

// Worker code:

export default {
    async fetch(request: Request, env: Env) {
        let url = new URL(request.url);
        let name = url.searchParams.get('name');
        if (!name) {
            return new Response('Select a Durable Object to contact by using' + ' the `name` URL query string parameter, for example, ?name=A');
        }

        let id = env.COUNTER.idFromName(name);

        // Construct the stub for the Durable Object using the ID.
        // A stub is a client Object used to send messages to the Durable Object.
        let obj = env.COUNTER.get(id);

        // Send a request to the Durable Object, then await its response.
        return obj.fetch(url);
    },
};

// Durable Object

export class Counter {
    state: DurableObjectState;
    webSockets: Set<WebSocket>;
    constructor(state: DurableObjectState, env: Env) {
        this.state = state;
        this.webSockets = new Set();
    }
    // Define the broadcast function
    broadcast(message: string) {
        this.webSockets.forEach((ws) => {
            ws.send(message);
        });
    }
    // Handle requests sent to the Durable Object
    async fetch(request: Request) {
        // Apply requested action.
        let url = new URL(request.url);
        // Check for websocket request
        console.log('DURABLE OBJECT', request.headers.get('Upgrade'));

        if (request.headers.get('Upgrade') === 'websocket') {
            const pair = new WebSocketPair();
            const { 0: clientWebSocket, 1: serverWebSocket } = pair;
            serverWebSocket.accept();
            this.webSockets.add(serverWebSocket);
            let value = Number((await this.state.storage.get('value')) || 0);
            serverWebSocket.send(JSON.stringify({ value }));
            // Handle websocket messages from the client as the server
            serverWebSocket.addEventListener('message', async (event) => {
                let data;
                if (typeof event.data !== 'string') {
                    serverWebSocket.send(JSON.stringify({ error: 'Invalid message format' }));
                    return;
                }
                try {
                    data = JSON.parse(event.data);
                } catch (error) {
                    serverWebSocket.send(JSON.stringify({ error: 'Invalid JSON' }));
                    return;
                }

                let value = Number((await this.state.storage.get('value')) || 0);

                switch (data.command) {
                    case 'increment':
                        value++;
                        break;
                    case 'decrement':
                        value--;
                        break;
                    default:
                        serverWebSocket.send(JSON.stringify({ error: 'Unknown command' }));
                        return;
                }

                await this.state.storage.put('value', value);

                // Broadcast the updated value to all clients
                this.broadcast(JSON.stringify({ value }));
            });

            // Remove the server websocket when it is closed
            serverWebSocket.addEventListener('close', (event) => {
                this.webSockets.delete(serverWebSocket);
            });

            // return the client websocket
            return new Response(null, { status: 101, webSocket: clientWebSocket });
        }
    }
}

ts
state: DurableObjectState;
webSockets: Set<WebSocket>;
storage: DurableObjectStorage;
constructor(state: DurableObjectState, env: Env) {
  this.state = state;
  this.storage = state.storage;
  this.webSockets = new Set();
}

HTTP 415 Unsupported Media type

Cf-resized: err=9412

/.wrangler/tmp/dev-BjjrCX/index.js

my/original/file.js

Error: Connection terminated unexpectedly

export const query = async (q, params) => {
    const client = new Client({
connectionString: env[env.DB+'-db'].connectionString,
        ssl: {rejectUnauthorized: false}
    });
    await client.connect();
    const res = await client.query(q, params);
    return res;
};

[[Hyperdrive]]

console.log(client)

readyForQuery: true

{
      '$$mdtype': 'Tag',
      name: 'Counter',
      attributes: [Object],
      children: []
    }

Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: undefined.

{
      '$$mdtype': 'Tag',
      name: '_R',
      attributes: [Object],
      children: []
    }

transform

const ast = parse(markdown) 
const config = {
        tags: { counter, },
       
    }
    return transform(ast, config)
`

pathname