@lensjs/adonis 1.0.12 → 1.1.0

package/build/configure.js

@@ -15,12 +15,13 @@ import { stubsRoot } from './stubs/main.js';
 const registerEnvValidation = async (codemods) => {
     try {
         await codemods.defineEnvValidations({
-            leadingComment: 'Node lens variables',
+            leadingComment: 'LensJs variables',
             variables: {
                 LENS_BASE_PATH: 'Env.schema.string.optional()',
                 LENS_ENABLED: 'Env.schema.boolean.optional()',
                 LENS_ENABLE_QUERY_WATCHER: 'Env.schema.boolean.optional()',
                 LENS_ENABLE_REQUEST_WATCHER: 'Env.schema.boolean.optional()',
+                LENS_ENABLE_CACHE_WATCHER: 'Env.schema.boolean.optional()',
             },
         });
     }
@@ -28,11 +29,24 @@ const registerEnvValidation = async (codemods) => {
         console.error(error);
     }
 };
+const registerMiddleware = async (codemods) => {
+    try {
+        codemods.registerMiddleware('router', [
+            {
+                path: '@lens/adonis/lens_middleware',
+            },
+        ]);
+    }
+    catch (error) {
+        console.error(error);
+    }
+};
 export async function configure(command) {
     const codemods = await command.createCodemods();
     await registerEnvValidation(codemods);
+    await registerMiddleware(codemods);
     await codemods.makeUsingStub(stubsRoot, 'config/lens.stub', {});
     await codemods.updateRcFile((rcFile) => {
-        rcFile.addProvider('@lensjs/adonis/lens_provider');
+        rcFile.addProvider('@lens/adonis/lens_provider');
     });
 }

package/build/providers/lens_service_provider.js

@@ -1,6 +1,6 @@
 import { configProvider } from '@adonisjs/core';
 import { RuntimeException } from '@poppinss/utils';
-import { Lens, lensUtils, RequestWatcher, QueryWatcher } from '@lensjs/core';
+import { Lens, lensUtils, RequestWatcher, QueryWatcher, CacheWatcher } from '@lensjs/core';
 import AdonisAdapter from '../src/adapter.js';
 export default class LensServiceProvider {
     app;
@@ -20,6 +20,7 @@ export default class LensServiceProvider {
             const watchersMap = {
                 requests: new RequestWatcher(),
                 queries: new QueryWatcher(),
+                cache: new CacheWatcher(),
             };
             const allowedWatchers = Object.keys(config.watchers)
                 .filter((watcher) => config.watchers[watcher])

package/build/src/adapter.d.ts

@@ -1,4 +1,4 @@
-import { RouteDefinition, LensAdapter, RequestWatcher, QueryWatcher } from '@lensjs/core';
+import { RouteDefinition, LensAdapter, RequestWatcher, QueryWatcher, CacheWatcher } from '@lensjs/core';
 import type { ApplicationService, EmitterService, HttpRouterService } from '@adonisjs/core/types';
 import { LensConfig } from './define_config.js';
 export default class AdonisAdapter extends LensAdapter {
@@ -16,6 +16,7 @@ export default class AdonisAdapter extends LensAdapter {
     registerRoutes(routes: RouteDefinition[]): void;
     protected watchRequests(requestWatcher: RequestWatcher): void;
     protected watchQueries(queryWatcher: QueryWatcher): Promise<void>;
+    protected watchCache(watcher: CacheWatcher): Promise<void>;
     serveUI(uiPath: string, spaRoute: string, _dataToInject: Record<string, any>): void;
     private matchStaticFiles;
     private getUserFromContext;

package/build/src/adapter.js

@@ -1,8 +1,10 @@
 import { LensAdapter, WatcherTypeEnum, lensUtils, } from '@lensjs/core';
 import * as path from 'path';
-import { shouldIgnoreLogging } from './utils/index.js';
+import { assertCacheBindingRegistered, shouldIgnoreLogging } from './utils/index.js';
 import string from '@adonisjs/core/helpers/string';
-import { nowISO, sqlDateTime } from '@lensjs/date';
+import { HttpContext } from '@adonisjs/core/http';
+import { nowISO } from '@lensjs/date';
+import emitter from '@adonisjs/core/services/emitter';
 export default class AdonisAdapter extends LensAdapter {
     app;
     router;
@@ -28,6 +30,9 @@ export default class AdonisAdapter extends LensAdapter {
                         this.queryWatcher = watcher;
                         await this.watchQueries(watcher);
                         break;
+                    case WatcherTypeEnum.CACHE:
+                        this.watchCache(watcher);
+                        break;
                 }
             }
         });
@@ -54,7 +59,7 @@ export default class AdonisAdapter extends LensAdapter {
             if (self.shouldIgnorePath(event.ctx.request.url(false)))
                 return;
             const request = event.ctx.request;
-            const requestId = lensUtils.generateRandomUuid();
+            const requestId = event.ctx.request.lensEntry?.requestId ?? lensUtils.generateRandomUuid();
             const logPayload = {
                 request: {
                     id: requestId,
@@ -82,20 +87,89 @@ export default class AdonisAdapter extends LensAdapter {
             if (shouldIgnoreLogging(self.app))
                 return;
             // @ts-ignore
-            this.emitter.on('db:query', async function (query) {
+            emitter.on('db:query', async function (query) {
+                const requestId = HttpContext.get()?.request.lensEntry?.requestId;
                 const duration = query.duration ? string.prettyHrTime(query.duration) : '0 ms';
                 const payload = {
                     query: lensUtils.formatSqlQuery(lensUtils.interpolateQuery(query.sql, query.bindings), self.config.watchers.queries.provider),
                     duration,
-                    createdAt: sqlDateTime(),
+                    createdAt: nowISO(),
                     type: self.config.watchers.queries.provider,
                 };
                 await queryWatcher.log({
                     data: payload,
+                    requestId,
                 });
             });
         });
     }
+    async watchCache(watcher) {
+        if (!this.config.watchers.cache)
+            return;
+        assertCacheBindingRegistered(this.app);
+        // Clear
+        // @ts-expect-error
+        this.emitter.on('cache:cleared', async (event) => {
+            await watcher.log({
+                action: 'clear',
+                data: {
+                    key: event.key,
+                },
+                createdAt: nowISO(),
+                requestId: HttpContext.get()?.request.lensEntry?.requestId,
+            });
+        });
+        // Write
+        // @ts-expect-error
+        this.emitter.on('cache:written', async (event) => {
+            await watcher.log({
+                action: 'write',
+                data: {
+                    key: event.key,
+                    value: event.value,
+                },
+                createdAt: nowISO(),
+                requestId: HttpContext.get()?.request.lensEntry?.requestId,
+            });
+        });
+        // Hit
+        // @ts-expect-error
+        this.emitter.on('cache:hit', async (event) => {
+            await watcher.log({
+                action: 'hit',
+                data: {
+                    key: event.key,
+                    value: event.value,
+                },
+                createdAt: nowISO(),
+                requestId: HttpContext.get()?.request.lensEntry?.requestId,
+            });
+        });
+        // Miss
+        // @ts-expect-error
+        this.emitter.on('cache:miss', async (event) => {
+            await watcher.log({
+                action: 'miss',
+                data: {
+                    key: event.key,
+                },
+                createdAt: nowISO(),
+                requestId: HttpContext.get()?.request.lensEntry?.requestId,
+            });
+        });
+        // Delete
+        // @ts-expect-error
+        this.emitter.on('cache:deleted', async (event) => {
+            await watcher.log({
+                action: 'delete',
+                data: {
+                    key: event.key,
+                },
+                createdAt: nowISO(),
+                requestId: HttpContext.get()?.request.lensEntry?.requestId,
+            });
+        });
+    }
     serveUI(uiPath, spaRoute, _dataToInject) {
         this.app.booted(async () => {
             this.router.get(`/${spaRoute}/favicon.ico`, (ctx) => {

package/build/src/define_config.d.ts

@@ -12,6 +12,7 @@ export type LensConfig = {
             enabled: boolean;
             provider: AdonisQueryType;
         };
+        cache: boolean;
         requests: boolean;
     };
     isAuthenticated?: (ctx: HttpContext) => Promise<boolean>;

package/build/src/middlewares/lens_middleware.d.ts

@@ -0,0 +1,12 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { NextFn } from '@adonisjs/core/types/http';
+declare module '@adonisjs/core/http' {
+    interface Request {
+        lensEntry?: {
+            requestId: string;
+        };
+    }
+}
+export default class LensMiddleware {
+    handle(ctx: HttpContext, next: NextFn): Promise<any>;
+}

package/build/src/middlewares/lens_middleware.js

@@ -0,0 +1,10 @@
+import { lensUtils } from '@lensjs/core';
+export default class LensMiddleware {
+    async handle(ctx, next) {
+        const lensEntry = {
+            requestId: lensUtils.generateRandomUuid(),
+        };
+        ctx.request.lensEntry = lensEntry;
+        return await next();
+    }
+}

package/build/src/utils/index.d.ts

@@ -3,6 +3,7 @@ import { HttpContext } from '@adonisjs/core/http';
 import { LensConfig } from '../define_config.js';
 export declare const runningInConsole: (app: ApplicationService) => boolean;
 export declare const getRunningCommand: () => string;
+export declare const assertCacheBindingRegistered: (app: ApplicationService) => void;
 export declare function allowedCommands(): boolean;
 export declare const shouldIgnoreLogging: (app: ApplicationService) => boolean;
 export declare const resolveConfigFromContext: (ctx: HttpContext) => Promise<LensConfig>;

package/build/src/utils/index.js

@@ -20,6 +20,16 @@ before creating a new Ignitor instance in:
     }
     return cmd;
 };
+export const assertCacheBindingRegistered = (app) => {
+    if (!app.container.hasBinding('cache.manager')) {
+        const message = `
+${chalk.red.bold('✖ Cache binding not registered')}
+
+Make sure to install @adonisjs/cache package to use cache watcher.
+`;
+        throw new Error(message);
+    }
+};
 export function allowedCommands() {
     const command = getRunningCommand();
     return ['queue:listen', 'schedule:work'].includes(command ?? 'WRONG');

package/build/stubs/config/lens.stub

@@ -12,6 +12,7 @@ const lensConfig = defineConfig({
   onlyPaths: [],
   watchers: {
     requests: env.get('LENS_ENABLE_REQUEST_WATCHER', true),
+    cache: env.get('LENS_ENABLE_CACHE_WATCHER', false),
     queries: {
       enabled: env.get('LENS_ENABLE_QUERY_WATCHER', true),
       provider: 'sqlite', // Change to your database provider

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lensjs/adonis",
   "description": "AdonisJs adapter for lens package",
-  "version": "1.0.12",
+  "version": "1.1.0",
   "engines": {
     "node": ">=20.6.0"
   },
@@ -47,7 +47,7 @@
   "dependencies": {
     "@poppinss/utils": "^6.10.1",
     "chalk": "^5.6.0",
-    "@lensjs/core": "1.0.12",
+    "@lensjs/core": "2.0.0",
     "@lensjs/date": "1.0.12"
   },
   "publishConfig": {