Debugging fetch in a consumer

Yes, I'm

await

await

ing the

fetch

fetch

and I also put inside a

try/catch

try/catch

, but no error is logged.
The last log I see is the

API URL

API URL

log, and then the code skips everything below the log

try {
    console.log('API URL :', `${env.STRAPI_API_URL}/c-orders`);
    const connection = await fetch(`${env.STRAPI_API_URL}/c-orders`, {
      headers: {
        Authorization: `Bearer ${env.STRAPI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      method: 'POST',
      body: JSON.stringify({
        data: {
          planId,
          date: new Date(),
          deliveryDate: new Date(deliveryDate * 1000),
          status: 1,
          details,
          grossPrice: totalPrice,
          finalPrice: totalPrice,
          subscriptionId: subscription ? strapiSubscriptionId : null,
          userId,
          paymentId: paymentIntent,
          paymentStatus: subscription ? 'processing' : 'success',
          orderInfo: [],
          stripeInvoiceId: invoice,
        },
      }),
    });

    console.log('connection :', connection);
    const data = await connection.json();
    console.log('data :', JSON.stringify(data, null, 2));

    if (connection.status !== 200) wasOrderCreated = false;

    wasOrderCreated = true;
  } catch (err) {
    console.log('err :', err);
    return false;
  }

try {
    console.log('API URL :', `${env.STRAPI_API_URL}/c-orders`);
    const connection = await fetch(`${env.STRAPI_API_URL}/c-orders`, {
      headers: {
        Authorization: `Bearer ${env.STRAPI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      method: 'POST',
      body: JSON.stringify({
        data: {
          planId,
          date: new Date(),
          deliveryDate: new Date(deliveryDate * 1000),
          status: 1,
          details,
          grossPrice: totalPrice,
          finalPrice: totalPrice,
          subscriptionId: subscription ? strapiSubscriptionId : null,
          userId,
          paymentId: paymentIntent,
          paymentStatus: subscription ? 'processing' : 'success',
          orderInfo: [],
          stripeInvoiceId: invoice,
        },
      }),
    });

    console.log('connection :', connection);
    const data = await connection.json();
    console.log('data :', JSON.stringify(data, null, 2));

    if (connection.status !== 200) wasOrderCreated = false;

    wasOrderCreated = true;
  } catch (err) {
    console.log('err :', err);
    return false;
  }

try {
    console.log('API URL :', `${env.STRAPI_API_URL}/c-orders`);
    const connection = await fetch(`${env.STRAPI_API_URL}/c-orders`, {
      headers: {
        Authorization: `Bearer ${env.STRAPI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      method: 'POST',
      body: JSON.stringify({
        data: {
          planId,
          date: new Date(),
          deliveryDate: new Date(deliveryDate * 1000),
          status: 1,
          details,
          grossPrice: totalPrice,
          finalPrice: totalPrice,
          subscriptionId: subscription ? strapiSubscriptionId : null,
          userId,
          paymentId: paymentIntent,
          paymentStatus: subscription ? 'processing' : 'success',
          orderInfo: [],
          stripeInvoiceId: invoice,
        },
      }),
    });

    console.log('connection :', connection);
    const data = await connection.json();
    console.log('data :', JSON.stringify(data, null, 2));

    if (connection.status !== 200) wasOrderCreated = false;

    wasOrderCreated = true;
  } catch (err) {
    console.log('err :', err);
    return false;
  }

try {
    console.log('API URL :', `${env.STRAPI_API_URL}/c-orders`);
    const connection = await fetch(`${env.STRAPI_API_URL}/c-orders`, {
      headers: {
        Authorization: `Bearer ${env.STRAPI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      method: 'POST',
      body: JSON.stringify({
        data: {
          planId,
          date: new Date(),
          deliveryDate: new Date(deliveryDate * 1000),
          status: 1,
          details,
          grossPrice: totalPrice,
          finalPrice: totalPrice,
          subscriptionId: subscription ? strapiSubscriptionId : null,
          userId,
          paymentId: paymentIntent,
          paymentStatus: subscription ? 'processing' : 'success',
          orderInfo: [],
          stripeInvoiceId: invoice,
        },
      }),
    });

    console.log('connection :', connection);
    const data = await connection.json();
    console.log('data :', JSON.stringify(data, null, 2));

    if (connection.status !== 200) wasOrderCreated = false;

    wasOrderCreated = true;
  } catch (err) {
    console.log('err :', err);
    return false;
  }

Matt Silverlock•9/26/23, 11:28 AM

Can you show the entire consumer code, just to make sure nothing is missed?

Matt Silverlock•9/26/23, 11:28 AM

And is this running locally or is it deployed?

Matt Silverlock•9/26/23, 11:28 AM

cc @Charlie B | KV, Queues, PubSub

nunoOP•9/26/23, 11:33 AM

async queue(batch: MessageBatch<Stripe.Event>, env: Env): Promise<void> {
    console.log('batch :', JSON.stringify(batch, null, 2));

    batch.messages.forEach(async (m) => {
      if (isStripeEvent(m.body))
        (await handleStripeEvents(m.body, env)) ? m.ack() : m.retry();
    });
  },

async queue(batch: MessageBatch<Stripe.Event>, env: Env): Promise<void> {
    console.log('batch :', JSON.stringify(batch, null, 2));

    batch.messages.forEach(async (m) => {
      if (isStripeEvent(m.body))
        (await handleStripeEvents(m.body, env)) ? m.ack() : m.retry();
    });
  },

export async function handleStripeEvents(
  event: Stripe.Event,
  env: Env,
): Promise<boolean> {
  switch (event.type) {
    case 'checkout.session.completed':
      return await checkoutCompleted(event, env);
    case 'invoice.payment_succeeded':
    case 'invoice.payment_failed':
      return true;
  }

  return true;
}

export async function handleStripeEvents(
  event: Stripe.Event,
  env: Env,
): Promise<boolean> {
  switch (event.type) {
    case 'checkout.session.completed':
      return await checkoutCompleted(event, env);
    case 'invoice.payment_succeeded':
    case 'invoice.payment_failed':
      return true;
  }

  return true;
}

nunoOP•9/26/23, 11:33 AM

MMatt Silverlock And is this running _locally_ or is it deployed?

nunoOP•9/26/23, 11:34 AM

I tried both, same behavior

Nnuno ```ts async queue(batch: MessageBatch<Stripe.Event>, env: Env): Promise<void> { ...

John Spurlock•9/26/23, 3:25 PM

did you try a normal for of loop instead of

batch.messages.forEach

batch.messages.forEach

? what you have now will just create a bunch of unresolved promises - forEach is not really ideal for async

CCharlie Yeah that's my instinct as well. I see us using a lot of modern syntax that migh...

John Spurlock•9/26/23, 3:48 PM

us meaning cloudflare? Hopefully you are not using

batch.messages.forEach

batch.messages.forEach

in any public samples!

John Spurlock•9/26/23, 3:49 PM

ideally cf would show the logs even from work that occurs after the

queue

queue

handler returns

John Spurlock•9/26/23, 3:51 PM

i wonder what the guidance/semantics is around work intended to be deferred until after the queue handler returns (ie not really like this case) - same as with

fetch

fetch

handlers:

waitUntil

waitUntil

? Or do you wait for all pending promises up to a certain limit like DO

JJohn Spurlock did you try a normal for of loop instead of `batch.messages.forEach` ? what you...

nunoOP•9/26/23, 4:09 PM

Not sure if this is the case here. I'm just triggering one event at a time, but if this code isn't ideal I'll change and test

Nnuno Not sure if this is the case here. I'm just triggering one event at a time, but ...

John Spurlock•9/26/23, 4:10 PM

that foreach is sync and will fire off your code async, and not wait for it

John Spurlock•9/26/23, 4:11 PM

yea just change to

for (const m of batch.messages) {

for (const m of batch.messages) {

that way you can wait for the results

John Spurlock•9/26/23, 4:12 PM

await Promise.all(batch.messages.map(work))

await Promise.all(batch.messages.map(work))

if you want to be fancy and run them all in parallel (prob overkill in your case)

nunoOP•9/26/23, 4:12 PM

Got it

nunoOP•9/26/23, 4:12 PM

thank, will do

nunoOP•9/26/23, 4:20 PM

It works, thanks @John Spurlock wumpus_party

John Spurlock•9/26/23, 4:20 PM

nice!

John Spurlock•9/26/23, 4:22 PM

that'll be better for errors too, if your external fetch call throws, the error will now be raised up and out of the queue handler - triggering the infrastructure to retry that message later, which is probably what you want never mind, you have a giant try catch around it! : )

JJohn Spurlock ~~that'll be better for errors too, if your external fetch call throws, the erro...

nunoOP•9/26/23, 4:23 PM

Got it, thanks for your explanation and help

JJohn Spurlock i wonder what the guidance/semantics is around work _intended_ to be deferred un...

Matt Silverlock•9/26/23, 6:29 PM

waitUntil. Anything else is undefined (and should, as of now, be cancelled immediately when the handler returns)

MMatt Silverlock waitUntil. Anything else is undefined (and should, as of now, be cancelled immed...

John Spurlock•9/26/23, 6:33 PM

thanks - wouldn't expect deferred logic to be nearly as desired for

queue

queue

where no clients are potentially waiting vs

fetch

fetch

where they potentially are - and most failures I'd imagine you'd want to wait for, before ack or not. only use case for deferred/waitUntil I could see for queue logic is analytics pings, where you might not want them in the critical path for processing, and don't care if some never make it

JJohn Spurlock thanks - wouldn't expect deferred logic to be nearly as desired for `queue` wher...

Matt Silverlock•9/26/23, 6:34 PM

Yep, that's exactly right - metrics/logging after the fact. We should probably document this a little more clearly and although

forEach

forEach

and the interaction with promises isn't our problem, also document that

Matt Silverlock•9/26/23, 6:35 PM

cc @Charlie B | KV, Queues, PubSub ^

async queue(batch: MessageBatch<Stripe.Event>, env: Env): Promise<void> { console.log('batch :', JSON.stringify(batch, null, 2)); batch.messages.forEach(async (m) => { if (isStripeEvent(m.body)) (await handleStripeEvents(m.body, env)) ? m.ack() : m.retry(); }); },

export async function handleStripeEvents( event: Stripe.Event, env: Env, ): Promise<boolean> { switch (event.type) { case 'checkout.session.completed': return await checkoutCompleted(event, env); case 'invoice.payment_succeeded': case 'invoice.payment_failed': return true; } return true; }

Debugging fetch in a consumer

Similar Threads

Similar Threads

Similar Threads