@safaricom-mxl/nuxthub 0.0.3

package/README.md

@@ -0,0 +1,61 @@
+# @safaricom-mxl/nuxthub
+
+[![npm version](https://img.shields.io/npm/v/@safaricom-mxl/nuxthub?color=black)](https://npmjs.com/package/@safaricom-mxl/nuxthub)
+[![npm downloads](https://img.shields.io/npm/dm/@safaricom-mxl/nuxthub?color=black)](https://npm.chart.dev/@safaricom-mxl/nuxthub)
+[![CI](https://img.shields.io/github/actions/workflow/status/HugoRCD/mxllog/ci.yml?branch=main&color=black)](https://github.com/HugoRCD/mxllog/actions/workflows/ci.yml)
+[![TypeScript](https://img.shields.io/badge/TypeScript-black?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Nuxt](https://img.shields.io/badge/Nuxt-black?logo=nuxt&logoColor=white)](https://nuxt.com/)
+[![Documentation](https://img.shields.io/badge/Documentation-black?logo=readme&logoColor=white)](https://mxllog.dev)
+[![license](https://img.shields.io/github/license/HugoRCD/mxllog?color=black)](https://github.com/HugoRCD/mxllog/blob/main/LICENSE)
+
+Self-hosted log retention for [mxllog](https://mxllog.dev) using [NuxtHub](https://hub.nuxt.com) database storage. Store, query, and automatically clean up your structured logs with zero external dependencies.
+
+## Setup
+
+Install the packages:
+
+```bash
+npx nuxi module add @nuxthub/core @safaricom-mxl/nuxthub
+```
+
+Add the module to your `nuxt.config.ts`:
+
+```typescript
+export default defineNuxtConfig({
+  modules: ['@nuxthub/core', '@safaricom-mxl/nuxthub'],
+
+  mxllog: {
+    retention: '7d',
+  },
+})
+```
+
+> `@safaricom-mxl/log/nuxt` and `@nuxthub/core` can be auto-installed if missing, but we recommend installing `@nuxthub/core` explicitly and registering it in `modules`.
+
+## Configuration
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `retention` | `string` | `'7d'` | How long to keep events. Accepts `d` (days), `h` (hours), or `m` (minutes). |
+
+The cleanup cron schedule is automatically derived from the retention value.
+
+## Database Support
+
+NuxtHub supports multiple database dialects. The `mxllog_events` table schema is automatically registered for:
+
+- **SQLite** (default for Cloudflare D1)
+- **MySQL**
+- **PostgreSQL**
+
+## Deployment
+
+For Vercel deployments, the module can create a `vercel.json` with the appropriate cron schedule during `nuxi module add`. For Cloudflare and other platforms, the Nitro scheduled task handles cleanup automatically.
+
+## Documentation
+
+[Full documentation](https://mxllog.dev)
+
+## License
+
+[MIT](https://github.com/HugoRCD/mxllog/blob/main/LICENSE)

package/dist/module.d.mts

@@ -0,0 +1,5 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+declare const _default: _nuxt_schema.NuxtModule<_nuxt_schema.ModuleOptions, _nuxt_schema.ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@safaricom-mxl/nuxthub",
+  "version": "0.0.3",
+  "configKey": "@safaricom-mxl/nuxthub",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,91 @@
+import { existsSync, promises } from 'node:fs';
+import { resolve } from 'node:path';
+import { defineNuxtModule, createResolver, hasNuxtModule, installModule, addTypeTemplate, addServerPlugin, addServerHandler } from '@nuxt/kit';
+import { consola } from 'consola';
+import { retentionToCron } from '../dist/runtime/utils/retention.js';
+
+const name = "@safaricom-mxl/nuxthub";
+const version = "0.0.3";
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name,
+    version
+  },
+  async onInstall(nuxt) {
+    const shouldSetup = await consola.prompt(
+      "Do you want to create a vercel.json with a cron schedule for mxllog cleanup?",
+      { type: "confirm", initial: false }
+    );
+    if (typeof shouldSetup !== "boolean" || !shouldSetup) return;
+    const vercelJsonPath = resolve(nuxt.options.rootDir, "vercel.json");
+    let config = {};
+    if (existsSync(vercelJsonPath)) {
+      config = JSON.parse(await promises.readFile(vercelJsonPath, "utf-8"));
+    }
+    const mxllogConfig = nuxt.options.mxllog || {};
+    const retention = mxllogConfig.retention ?? "7d";
+    const cron = retentionToCron(retention);
+    const crons = config.crons || [];
+    const existing = crons.findIndex((c) => c.path === "/api/_cron/mxllog-cleanup");
+    if (existing >= 0) {
+      crons[existing].schedule = cron;
+    } else {
+      crons.push({ path: "/api/_cron/mxllog-cleanup", schedule: cron });
+    }
+    config.crons = crons;
+    await promises.writeFile(vercelJsonPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+    consola.success("Created vercel.json with mxllog cleanup cron schedule");
+  },
+  async setup(_moduleOptions, nuxt) {
+    const { resolve: resolve2 } = createResolver(import.meta.url);
+    if (!hasNuxtModule("@safaricom-mxl/log/nuxt")) {
+      await installModule("@safaricom-mxl/log/nuxt");
+    }
+    if (!hasNuxtModule("@nuxthub/core")) {
+      await installModule("@nuxthub/core");
+    }
+    addTypeTemplate({
+      filename: "types/mxllog-nuxthub.d.ts",
+      getContents: () => [
+        "declare module '@safaricom-mxl/log/nuxt' {",
+        "  interface ModuleOptions {",
+        "    retention?: string",
+        "  }",
+        "}",
+        "export {}"
+      ].join("\n")
+    });
+    const mxllogConfig = nuxt.options.mxllog || {};
+    const retention = mxllogConfig.retention ?? "7d";
+    nuxt.hook("hub:db:schema:extend", ({ dialect, paths }) => {
+      paths.push(resolve2(`./runtime/db/schema/events.${dialect}`));
+    });
+    addServerPlugin(resolve2("./runtime/drain"));
+    addServerHandler({
+      route: "/api/_cron/mxllog-cleanup",
+      handler: resolve2("./runtime/api/_cron/mxllog-cleanup")
+    });
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.experimental = nitroConfig.experimental || {};
+      nitroConfig.experimental.tasks = true;
+      nitroConfig.tasks = nitroConfig.tasks || {};
+      nitroConfig.tasks["@safaricom-mxl/log:cleanup"] = {
+        handler: resolve2("./runtime/tasks/mxllog-cleanup")
+      };
+      const cron = retentionToCron(retention);
+      nitroConfig.scheduledTasks = nitroConfig.scheduledTasks || {};
+      const existing = nitroConfig.scheduledTasks[cron];
+      if (Array.isArray(existing)) {
+        existing.push("@safaricom-mxl/log:cleanup");
+      } else if (existing) {
+        nitroConfig.scheduledTasks[cron] = [existing, "@safaricom-mxl/log:cleanup"];
+      } else {
+        nitroConfig.scheduledTasks[cron] = ["@safaricom-mxl/log:cleanup"];
+      }
+    });
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/api/_cron/mxllog-cleanup.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    result?: unknown;
+    success: boolean;
+}>>;
+export default _default;

package/dist/runtime/api/_cron/mxllog-cleanup.js

@@ -0,0 +1,13 @@
+import { runTask } from "nitropack/runtime";
+import { eventHandler, getHeader, createError } from "h3";
+export default eventHandler(async (event) => {
+  const cronSecret = process.env.CRON_SECRET;
+  if (cronSecret) {
+    const authorization = getHeader(event, "authorization");
+    if (authorization !== `Bearer ${cronSecret}`) {
+      throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+    }
+  }
+  const result = await runTask("@safaricom-mxl/log:cleanup");
+  return { success: true, ...result };
+});

package/dist/runtime/db/schema/events.mysql.d.ts

@@ -0,0 +1,245 @@
+export declare const mxllogEvents: import("drizzle-orm/mysql-core").MySqlTableWithColumns<{
+    name: "mxllog_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "id";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        timestamp: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "timestamp";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        level: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "level";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        service: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "service";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        environment: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "environment";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        method: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "method";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        path: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "path";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "status";
+            tableName: "mxllog_events";
+            dataType: "number";
+            columnType: "MySqlInt";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        durationMs: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "duration_ms";
+            tableName: "mxllog_events";
+            dataType: "number";
+            columnType: "MySqlInt";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requestId: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "request_id";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "source";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "error";
+            tableName: "mxllog_events";
+            dataType: "json";
+            columnType: "MySqlJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        data: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "data";
+            tableName: "mxllog_events";
+            dataType: "json";
+            columnType: "MySqlJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "created_at";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "MySqlText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "mysql";
+}>;

package/dist/runtime/db/schema/events.mysql.js

@@ -0,0 +1,24 @@
+import { index, int, json, mysqlTable, text } from "drizzle-orm/mysql-core";
+export const mxllogEvents = mysqlTable("mxllog_events", {
+  id: text("id").primaryKey(),
+  timestamp: text("timestamp").notNull(),
+  level: text("level").notNull(),
+  service: text("service").notNull(),
+  environment: text("environment").notNull(),
+  method: text("method"),
+  path: text("path"),
+  status: int("status"),
+  durationMs: int("duration_ms"),
+  requestId: text("request_id"),
+  source: text("source"),
+  error: json("error"),
+  data: json("data"),
+  createdAt: text("created_at").notNull()
+}, (table) => [
+  index("mxllog_events_timestamp_idx").on(table.timestamp),
+  index("mxllog_events_level_idx").on(table.level),
+  index("mxllog_events_service_idx").on(table.service),
+  index("mxllog_events_status_idx").on(table.status),
+  index("mxllog_events_request_id_idx").on(table.requestId),
+  index("mxllog_events_created_at_idx").on(table.createdAt)
+]);

package/dist/runtime/db/schema/events.postgresql.d.ts

@@ -0,0 +1,245 @@
+export declare const mxllogEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "mxllog_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        timestamp: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timestamp";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        level: import("drizzle-orm/pg-core").PgColumn<{
+            name: "level";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        service: import("drizzle-orm/pg-core").PgColumn<{
+            name: "service";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        environment: import("drizzle-orm/pg-core").PgColumn<{
+            name: "environment";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        method: import("drizzle-orm/pg-core").PgColumn<{
+            name: "method";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        path: import("drizzle-orm/pg-core").PgColumn<{
+            name: "path";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "mxllog_events";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        durationMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "duration_ms";
+            tableName: "mxllog_events";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requestId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "request_id";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "mxllog_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        data: import("drizzle-orm/pg-core").PgColumn<{
+            name: "data";
+            tableName: "mxllog_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/runtime/db/schema/events.postgresql.js

@@ -0,0 +1,24 @@
+import { index, integer, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+export const mxllogEvents = pgTable("mxllog_events", {
+  id: text("id").primaryKey(),
+  timestamp: text("timestamp").notNull(),
+  level: text("level").notNull(),
+  service: text("service").notNull(),
+  environment: text("environment").notNull(),
+  method: text("method"),
+  path: text("path"),
+  status: integer("status"),
+  durationMs: integer("duration_ms"),
+  requestId: text("request_id"),
+  source: text("source"),
+  error: jsonb("error"),
+  data: jsonb("data"),
+  createdAt: text("created_at").notNull()
+}, (table) => [
+  index("mxllog_events_timestamp_idx").on(table.timestamp),
+  index("mxllog_events_level_idx").on(table.level),
+  index("mxllog_events_service_idx").on(table.service),
+  index("mxllog_events_status_idx").on(table.status),
+  index("mxllog_events_request_id_idx").on(table.requestId),
+  index("mxllog_events_created_at_idx").on(table.createdAt)
+]);

package/dist/runtime/db/schema/events.sqlite.d.ts

@@ -0,0 +1,269 @@
+export declare const mxllogEvents: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "mxllog_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        timestamp: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "timestamp";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        level: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "level";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        service: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "service";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        environment: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "environment";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        method: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "method";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        path: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "path";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "mxllog_events";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        durationMs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "duration_ms";
+            tableName: "mxllog_events";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requestId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "request_id";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        source: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        error: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "error";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "data";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "mxllog_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/runtime/db/schema/events.sqlite.js

@@ -0,0 +1,24 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const mxllogEvents = sqliteTable("mxllog_events", {
+  id: text("id").primaryKey(),
+  timestamp: text("timestamp").notNull(),
+  level: text("level").notNull(),
+  service: text("service").notNull(),
+  environment: text("environment").notNull(),
+  method: text("method"),
+  path: text("path"),
+  status: integer("status"),
+  durationMs: integer("duration_ms"),
+  requestId: text("request_id"),
+  source: text("source"),
+  error: text("error"),
+  data: text("data"),
+  createdAt: text("created_at").notNull()
+}, (table) => [
+  index("mxllog_events_timestamp_idx").on(table.timestamp),
+  index("mxllog_events_level_idx").on(table.level),
+  index("mxllog_events_service_idx").on(table.service),
+  index("mxllog_events_status_idx").on(table.status),
+  index("mxllog_events_request_id_idx").on(table.requestId),
+  index("mxllog_events_created_at_idx").on(table.createdAt)
+]);

package/dist/runtime/drain.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/drain.js

@@ -0,0 +1,107 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { db, schema } from "@nuxthub/db";
+function parseDurationMs(event) {
+  if (typeof event.durationMs === "number") return event.durationMs;
+  if (typeof event.duration === "number") return event.duration;
+  if (typeof event.duration === "string") {
+    const str = event.duration;
+    const msMatch = str.match(/^([\d.]+)\s*ms$/);
+    if (msMatch) return Math.round(Number.parseFloat(msMatch[1]));
+    const sMatch = str.match(/^([\d.]+)\s*s$/);
+    if (sMatch) return Math.round(Number.parseFloat(sMatch[1]) * 1e3);
+  }
+  return null;
+}
+const INDEXED_FIELDS = /* @__PURE__ */ new Set([
+  "timestamp",
+  "level",
+  "service",
+  "environment",
+  "method",
+  "path",
+  "status",
+  "durationMs",
+  "duration",
+  "requestId",
+  "source",
+  "error"
+]);
+function extractRow(ctx) {
+  const { event, request } = ctx;
+  const data = {};
+  for (const [key, value] of Object.entries(event)) {
+    if (!INDEXED_FIELDS.has(key) && value !== void 0) {
+      data[key] = value;
+    }
+  }
+  const errorValue = event.error;
+  let errorJson = null;
+  if (errorValue !== void 0 && errorValue !== null) {
+    if (typeof errorValue === "string") {
+      errorJson = errorValue;
+    } else {
+      try {
+        errorJson = JSON.stringify(errorValue);
+      } catch {
+        errorJson = String(errorValue);
+      }
+    }
+  }
+  return {
+    id: crypto.randomUUID(),
+    timestamp: event.timestamp,
+    level: event.level,
+    service: event.service,
+    environment: event.environment,
+    method: (request?.method ?? event.method) || null,
+    path: (request?.path ?? event.path) || null,
+    status: typeof event.status === "number" ? event.status : null,
+    durationMs: parseDurationMs(event),
+    requestId: (request?.requestId ?? event.requestId) || null,
+    source: event.source || null,
+    error: errorJson,
+    data: Object.keys(data).length > 0 ? JSON.stringify(data) : null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+const MAX_ATTEMPTS = 3;
+const INITIAL_DELAY_MS = 500;
+const RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "CONNECT_TIMEOUT",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "CONNECTION_ENDED"
+]);
+function isRetryable(error) {
+  if (error instanceof Error) {
+    const cause = error.cause;
+    if (cause && typeof cause.code === "string") {
+      return RETRYABLE_CODES.has(cause.code);
+    }
+  }
+  return false;
+}
+async function insertWithRetry(rows) {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      await db.insert(schema.mxllogEvents).values(rows);
+      return;
+    } catch (error) {
+      if (attempt === MAX_ATTEMPTS || !isRetryable(error)) throw error;
+      await new Promise((r) => setTimeout(r, INITIAL_DELAY_MS * 2 ** (attempt - 1)));
+    }
+  }
+}
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("@safaricom-mxl/log:drain", async (ctx) => {
+    try {
+      const contexts = Array.isArray(ctx) ? ctx : [ctx];
+      if (contexts.length === 0) return;
+      const rows = contexts.map(extractRow);
+      await insertWithRetry(rows);
+    } catch (error) {
+      console.error("[mxllog/nuxthub] Failed to insert events:", error);
+    }
+  });
+});

package/dist/runtime/tasks/evlog-cleanup.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").Task<string>;
+export default _default;

package/dist/runtime/tasks/evlog-cleanup.js

@@ -0,0 +1,24 @@
+import { defineTask, useRuntimeConfig } from "nitropack/runtime";
+import { lt } from "drizzle-orm";
+import { db, schema } from "@nuxthub/db";
+import { parseRetention } from "../utils/retention.js";
+export default defineTask({
+  meta: {
+    name: "@safaricom-mxl/log:cleanup",
+    description: "Clean up expired mxllog events based on retention policy"
+  },
+  async run() {
+    const config = useRuntimeConfig();
+    const retention = config.mxllog?.retention ?? "7d";
+    const { totalMs } = parseRetention(retention);
+    const cutoff = new Date(Date.now() - totalMs).toISOString();
+    try {
+      const result = await db.delete(schema.mxllogEvents).where(lt(schema.mxllogEvents.createdAt, cutoff));
+      console.log(`[mxllog/nuxthub] Cleanup: deleted events older than ${retention} (before ${cutoff})`, result);
+      return { result: "success" };
+    } catch (error) {
+      console.error("[mxllog/nuxthub] Cleanup task failed:", error);
+      return { result: "error" };
+    }
+  }
+});

package/dist/runtime/utils/retention.d.ts

@@ -0,0 +1,7 @@
+export declare function parseRetention(retention: string): {
+    value: number;
+    unit: string;
+    totalMinutes: number;
+    totalMs: number;
+};
+export declare function retentionToCron(retention: string): string;

package/dist/runtime/utils/retention.js

@@ -0,0 +1,51 @@
+import { createMxllogError } from "@safaricom-mxl/log";
+export function parseRetention(retention) {
+  const match = retention.match(/^(\d+)(d|h|m)$/);
+  if (!match) {
+    throw createMxllogError({
+      message: `[mxllog/nuxthub] Invalid retention format: "${retention}"`,
+      why: "The retention value must be a number followed by a unit: d (days), h (hours), or m (minutes)",
+      fix: `Change retention to a valid format, e.g., "30d", "24h", or "60m"`,
+      link: "https://mxllog.dev/nuxthub/retention"
+    });
+  }
+  const [, numStr, unit] = match;
+  const num = Number(numStr);
+  let totalMinutes;
+  switch (unit) {
+    case "m":
+      totalMinutes = num;
+      break;
+    case "h":
+      totalMinutes = num * 60;
+      break;
+    case "d":
+      totalMinutes = num * 24 * 60;
+      break;
+    default:
+      throw createMxllogError({
+        message: `[mxllog/nuxthub] Unknown retention unit: "${unit}"`,
+        why: "The retention value must use one of the supported units: d (days), h (hours), or m (minutes)",
+        fix: `Change retention to a valid format, e.g., "30d", "24h", or "60m"`,
+        link: "https://mxllog.dev/nuxthub/retention"
+      });
+  }
+  return {
+    value: num,
+    unit,
+    totalMinutes,
+    totalMs: totalMinutes * 60 * 1e3
+  };
+}
+export function retentionToCron(retention) {
+  const { totalMinutes } = parseRetention(retention);
+  const halfMinutes = Math.max(1, Math.floor(totalMinutes / 2));
+  if (halfMinutes < 60) {
+    return `*/${halfMinutes} * * * *`;
+  }
+  const halfHours = Math.floor(halfMinutes / 60);
+  if (halfHours >= 24) {
+    return "0 3 * * *";
+  }
+  return `0 */${halfHours} * * *`;
+}

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@safaricom-mxl/nuxthub",
+  "version": "0.0.3",
+  "description": "Self-hosted log retention for mxllog using NuxtHub database storage",
+  "author": "Francis Konde <fkonde@safaricom.co.ke>",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "nuxthub",
+    "mxllog",
+    "logging",
+    "nuxt",
+    "drizzle",
+    "database"
+  ],
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^1.0.2",
+    "@safaricom-mxl/log": "workspace:*",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@safaricom-mxl/log": "workspace:*",
+    "@nuxthub/core": "^0.10.6",
+    "drizzle-orm": ">=0.45.1"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": false
+    },
+    "@safaricom-mxl/log": {
+      "optional": false
+    },
+    "@nuxthub/core": {
+      "optional": false
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}