app.register(Plugins.EventBus, {
  // Required: type of message broker to use
  busType: "rabbitmq" | "gcp-pubsub" | "azure-servicebus" | "in-process",

  // Required for gcp-pubsub and azure-servicebus
  topic: "your-topic-name",

  // Required for azure-servicebus
  namespace: "your-namespace",

  // Required: define event handlers
  handlers: [
    {
      file: "module-name",
      handlers: {
        "event-name": async function (msg, req) {
          // Handle the event
        },
      },
    },
  ],

  // Required: message validation function
  validateMsg: (event, payload, req) => {
    // Validate the message
  },

  // Required: error processing function
  processError: (err, ctx) => {
    // Process the error
    return { err, status: 500 };
  },

  // Optional: disable the /event-bus/publish/:event route
  disableEventPublishRoute: false,

  // Optional: control concurrency of event handlers
  actionConcurrency: 1,

  // Optional: Prometheus registry for metrics
  registry: new Registry(),
});

import { EventBus, Plugins } from "@stackbox/fp-plugins";

const app = fastify();

// Register event bus
app.register(Plugins.EventBus, {
  busType: "rabbitmq",
  validateMsg: (event, payload) => {
    // Validate event and payload
    console.log(`Validating message: ${event}`);
  },
  processError: (err, ctx) => {
    console.error(`Error processing message: ${err.message}`);
    return { err, status: 500 };
  },
  handlers: [
    {
      file: "orderModule",
      handlers: {
        "order.created": async function (msg, req) {
          // Process order created event
          console.log(`Processing order: ${msg.data.orderId}`);
        },
        "order.cancelled": async function (msg, req) {
          // Process order cancelled event
          console.log(`Processing cancelled order: ${msg.data.orderId}`);
        },
      },
    },
  ],
});

// Publishing events
app.post("/create-order", async (req, reply) => {
  // Create order logic...

  // Publish event
  req.EventBus.publish("order.created", {
    orderId: "order-123",
    customerId: "customer-456",
  });

  return { success: true };
});

// Delayed events (process after specified milliseconds)
app.post("/schedule-reminder", async (req, reply) => {
  req.EventBus.publish(
    "reminder.send",
    {
      userId: "user-123",
      message: "Reminder to complete your profile",
    },
    3600000,
  ); // Process after 1 hour

  return { scheduled: true };
});

import { CreateEventConsumer } from "@stackbox/fp-plugins";

// Create consumer that matches your EventBus busType
const consumer = await CreateEventConsumer(app, "rabbitmq");

// Close consumer when application shuts down
app.addHook("onClose", async () => {
  await consumer.close();
});

app.register(Plugins.FileStore, {
  // Required: type of storage provider to use
  type: "local" | "s3" | "gcs" | "azureBlob" | "minio",
});

interface FileStore {
  exists(filepath: string): Promise<boolean>;
  save(
    filepath: string,
    contentType: string,
    data: string | Buffer,
  ): Promise<void>;
  getAsBuffer(filepath: string): Promise<Buffer>;
  getAsStream(filepath: string): Promise<NodeJS.ReadableStream>;
  copyFromStream(
    filepath: string,
    contentType: string,
    stream: stream.Readable,
  ): Promise<void>;
  copyFromLocalFile(
    filepath: string,
    contentType: string,
    localFilepath: string,
  ): Promise<void>;
}

import { Plugins } from "@stackbox/fp-plugins";
import { fastify } from "fastify";

const app = fastify();

// Register file store plugin
app.register(Plugins.FileStore, {
  type: "s3", // Choose the appropriate storage type
});

// Using the file store
app.post("/upload", async (request, reply) => {
  const { filepath, contentType, data } = request.body;

  // Check if file exists
  const exists = await request.server.FileStore.exists(filepath);

  // Save file
  await request.server.FileStore.save(filepath, contentType, data);

  // Get file as buffer
  const fileContent = await request.server.FileStore.getAsBuffer(filepath);

  // Get file as stream
  const fileStream = await request.server.FileStore.getAsStream(filepath);

  // Copy from stream
  await request.server.FileStore.copyFromStream(
    filepath,
    contentType,
    someReadableStream,
  );

  // Copy from local file
  await request.server.FileStore.copyFromLocalFile(
    filepath,
    contentType,
    "/path/to/local/file",
  );

  return { success: true };
});