How to declare cronjob in Hono??

[dnguyenfs]

How can I create cronjob in Hono guys?

[yusukebe]

I'm not sure what you meant by "cronjob", but Hono is a slim framework, almost like a router, so it doesn't have a cron function.

However, if you were referring to Cloudflare Triggers, you can write it as follows:

export default {
  fetch: app.fetch,
  async scheduled(event, env, ctx) {
    ctx.waitUntil(doSomeTaskOnASchedule())
  }
}

[r0ckerz]

Can you please provide more details here?
What are (event, env, ctx) types? Why is ctx.waitUntil used here instead of event.waitUntil?
Is it possible to pass down env.Bindings from the main app so that KVNamespace can be accessed in a scheduled task? What would be the best way to do that? Thanks!

[EyalRo]

I tried this, and it breaks the hono routes (getting error 500). It also fails to expose the Cloudflare /__scheduled

[exoup]

Can you please provide more details here? What are (event, env, ctx) types? Why is ctx.waitUntil used here instead of event.waitUntil? Is it possible to pass down env.Bindings from the main app so that KVNamespace can be accessed in a scheduled task? What would be the best way to do that? Thanks!

@r0ckerz The example seems to come from the Cloudflare Workers docs here, which explains a bit about the various parameters.

[EyalRo]

I got this working nicely with something like this (in typescript): note that cronTask is just a function called on the cron schedule. You can use whatever works for you. I use the waitUntil method so I can guarantee to finish the cronTask function processing before the cloud function is terminated (all of this is running on Cloudflare workers):

export default {
/** this part manages cronjobs */
  scheduled(
    event: ScheduledEvent,
    env: {
      DB?: any;
      SENDGRID_API_KEY: any;
    },
    ctx: ExecutionContext
  ) {
    const delayedProcessing = async () => {
      await cronTask(env);
    };
    ctx.waitUntil(delayedProcessing());
  },
/** this part manages regular REST */
  fetch(request: Request, env: Env, ctx: ExecutionContext) {
    return app.fetch(request, env, ctx);
  },
};

in plain JS this should look something like this (js code untested):

export default {
  scheduled(event, env, ctx) {
    const delayedProcessing = async () => {
      await cronTask(env)
    }
    ctx.waitUntil(delayedProcessing())
  },
  fetch(request, env, ctx) {
    return app.fetch(request, env, ctx)
  }
}

[exoup]

Very helpful. Thanks!

[zinc1234596]

really thankful! This method works! ❤️

[kirtirajsinh]

I got this working nicely with something like this (in typescript): note that cronTask is just a function called on the cron schedule. You can use whatever works for you. I use the waitUntil method so I can guarantee to finish the cronTask function processing before the cloud function is terminated (all of this is running on Cloudflare workers):

export default {
/** this part manages cronjobs */
  scheduled(
    event: ScheduledEvent,
    env: {
      DB?: any;
      SENDGRID_API_KEY: any;
    },
    ctx: ExecutionContext
  ) {
    const delayedProcessing = async () => {
      await cronTask(env);
    };
    ctx.waitUntil(delayedProcessing());
  },
/** this part manages regular REST */
  fetch(request: Request, env: Env, ctx: ExecutionContext) {
    return app.fetch(request, env, ctx);
  },
};

in plain JS this should look something like this (js code untested):

export default {
  scheduled(event, env, ctx) {
    const delayedProcessing = async () => {
      await cronTask(env)
    }
    ctx.waitUntil(delayedProcessing())
  },
  fetch(request, env, ctx) {
    return app.fetch(request, env, ctx)
  }
}

This is my code and I tried all way but the scheduled function is not being called.

import { Hono } from "hono";
// import { handlePostResponse } from "./utils";
import { Bindings } from "./env.types";
import { handlePostResponse, replyWithARoast, roastthePost } from "./utils";
import { generateImage } from "./generate-image";
import { upload } from "../lib/upload";

export const app = new Hono<{ Bindings: Bindings }>();

app.get("/", async (c) => {

  return c.text("Hello buddha!");
});

app.post("/event", async (c) => {
  const body = await c.req.json();

  console.log(body, "original body");
  const response = await handlePostResponse(
    body,
    c.env
  );


  return c.json({
    data: response
  });
});

app.post("/generate-image", async (c) => {
  const body = await c.req.json();
  console.log(body, "original body");
  const svg = await generateImage(body.text, c.env);
  console.log(svg, "svg");

  const uplaodToS3 = await upload(svg, c.env);
  console.log(uplaodToS3, "uplaodToS3");



  return c.html(`
    <div>
      <h2>Generated SVG:</h2>
      ${svg}
    </div>
  `);



});

// Separate scheduler function
export default {
  /** this part manages cronjobs */
  scheduled(
    event: ScheduledEvent,
    env: Bindings,
    ctx: ExecutionContext
  ) {
    const createQuote = async () => {
      const quote = await roastthePost("generate a nice quote", "", env);
      if (quote) {
        const image = await generateImage(quote, env);
        const uplaodToS3 = await upload(image, env);
        console.log(uplaodToS3, "uplaodToS3");

        // const reply = await replyWithARoast(imageUrl: );
      }
    }
    ctx.waitUntil(createQuote());
  },
  /** this part manages regular REST */
  fetch(request: Request, env: Bindings, ctx: ExecutionContext) {
    return app.fetch(request, env, ctx);
  },
};

[EyalRo]

I see a couple of things that might be causing the issue:

There's a mix of ts and js; you might get better results using the js version of the export function (below).

export default {
  scheduled(event, env, ctx) {
    const createQuote = async () => {
    ...
    }
    ctx.waitUntil(createQuote());
  },
  fetch(request, env, ctx) {
    return app.fetch(request, env, ctx)
  }
}

Also, be aware that if something is wrong with the ctx.waitUntil, you might call the function but never finish running it because the lambda is shutting down.

[serk7]

Im not sure, but

export default {
  scheduled(event, env, ctx) {
    const createQuote = async () => {
    ...
    }
    ctx.waitUntil(createQuote());
  },
  fetch(request, env, ctx) {
    return app.fetch(request, env, ctx)
  }
}

is the same as:

export default {
  scheduled(event, env, ctx) {
    const createQuote = async () => {
    ...
    }
    ctx.waitUntil(createQuote());
  },
  fetch: app.fetch
  }
}

Isn't simplier?