@adonisjs/cache 1.0.0-0

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License
+
+Copyright (c) 2023
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# @adonisjs/cache
+
+<br />
+
+[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url]
+
+## Introduction
+Cache module for AdonisJS built on top of BentoCache. Support multiples drivers, File, In-Memory, Redis, SQLs databases and more.
+
+## Official Documentation
+The documentation is available on the [AdonisJS website](https://docs.adonisjs.com/guides/cache/introduction).
+
+## Contributing
+One of the primary goals of AdonisJS is to have a vibrant community of users and contributors who believes in the principles of the framework.
+
+We encourage you to read the [contribution guide](https://github.com/adonisjs/.github/blob/main/docs/CONTRIBUTING.md) before contributing to the framework.
+
+## Code of Conduct
+In order to ensure that the AdonisJS community is welcoming to all, please review and abide by the [Code of Conduct](https://github.com/adonisjs/.github/blob/main/docs/CODE_OF_CONDUCT.md).
+
+## License
+AdonisJS Lucid is open-sourced software licensed under the [MIT license](LICENSE.md).
+
+[gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/adonisjs/cache/test.yml?style=for-the-badge
+[gh-workflow-url]: https://github.com/adonisjs/cache/actions/workflows/test.yml "Github action"
+
+[npm-image]: https://img.shields.io/npm/v/@adonisjs/cache/latest.svg?style=for-the-badge&logo=npm
+[npm-url]: https://www.npmjs.com/package/@adonisjs/cache/v/latest "npm"
+
+[typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
+
+[license-url]: LICENSE.md
+[license-image]: https://img.shields.io/github/license/adonisjs/cache?style=for-the-badge

package/build/commands/cache_clear.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import { CommandOptions } from '@adonisjs/core/types/ace';
+export default class CacheClear extends BaseCommand {
+    #private;
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    /**
+     * Choose a custom cache store to clear. Otherwise, we use the
+     * default one
+     */
+    store: string;
+    /**
+     * Handle command
+     */
+    run(): Promise<void>;
+}

package/build/commands/cache_clear.js

@@ -0,0 +1,77 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, flags } from '@adonisjs/core/ace';
+export default class CacheClear extends BaseCommand {
+    static commandName = 'cache:clear';
+    static description = 'Clear the application cache';
+    static options = {
+        startApp: true,
+    };
+    /**
+     * Prompts to take consent when clearing the cache in production
+     */
+    async #takeProductionConsent() {
+        const question = 'You are in production environment. Want to continue clearing the cache?';
+        try {
+            return await this.prompt.confirm(question);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Check if the given cache exist
+     */
+    #cacheExists(cache, cacheName) {
+        try {
+            cache.use(cacheName);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Handle command
+     */
+    async run() {
+        const cache = await this.app.container.make('cache');
+        this.store = this.store || cache.defaultStoreName;
+        /**
+         * Exit if cache store doesn't exists
+         */
+        if (!this.#cacheExists(cache, this.store)) {
+            this.logger.error(`"${this.store}" is not a valid cache store. Double check config/cache.ts file`);
+            this.exitCode = 1;
+            return;
+        }
+        /**
+         * Take consent when clearing the cache in production
+         */
+        if (this.app.inProduction) {
+            const shouldClear = await this.#takeProductionConsent();
+            if (!shouldClear)
+                return;
+        }
+        /**
+         * Finally clear the cache
+         */
+        await cache.use(this.store).clear();
+        this.logger.success(`Cleared "${this.store}" cache successfully`);
+    }
+}
+__decorate([
+    flags.string({ description: 'Define a custom cache store to clear', alias: 's' })
+], CacheClear.prototype, "store", void 0);

package/build/commands/commands.json

@@ -0,0 +1 @@
+{"commands":[{"commandName":"cache:clear","description":"Clear the application cache","help":"","namespace":"cache","aliases":[],"flags":[{"name":"store","flagName":"store","required":false,"type":"string","description":"Define a custom cache store to clear","alias":"s"}],"args":[],"options":{"startApp":true},"filePath":"cache_clear.js","absoluteFilePath":"/home/julienr/code/adonis/cache/build/commands/cache_clear.js"}],"version":1}

package/build/commands/main.d.ts

@@ -0,0 +1,4 @@
+import { CommandMetaData, Command } from '@adonisjs/ace/types';
+
+export function getMetaData(): Promise<CommandMetaData[]>
+export function getCommand(metaData: CommandMetaData): Promise<Command | null>

package/build/commands/main.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * In-memory cache of commands after they have been loaded
+ */
+let commandsMetaData
+
+/**
+ * Reads the commands from the "./commands.json" file. Since, the commands.json
+ * file is generated automatically, we do not have to validate its contents
+ */
+export async function getMetaData() {
+  if (commandsMetaData) {
+    return commandsMetaData
+  }
+
+  const commandsIndex = await readFile(new URL('./commands.json', import.meta.url), 'utf-8')
+  commandsMetaData = JSON.parse(commandsIndex).commands
+
+  return commandsMetaData
+}
+
+/**
+ * Imports the command by lookingup its path from the commands
+ * metadata
+ */
+export async function getCommand(metaData) {
+  const commands = await getMetaData()
+  const command = commands.find(({ commandName }) => metaData.commandName === commandName)
+  if (!command) {
+    return null
+  }
+
+  const { default: commandConstructor } = await import(new URL(command.filePath, import.meta.url).href)
+  return commandConstructor
+}

package/build/configure.d.ts

@@ -0,0 +1,5 @@
+import type Configure from '@adonisjs/core/commands/configure';
+/**
+ * Configures the package
+ */
+export declare function configure(command: Configure): Promise<void>;

package/build/configure.js

@@ -0,0 +1,61 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+const DRIVERS = ['redis', 'file', 'memory', 'database', 'dynamodb'];
+const DRIVERS_INFO = {
+    file: {},
+    memory: {},
+    redis: {},
+    database: {},
+    dynamodb: {
+        envValidations: {
+            AWS_ACCESS_KEY_ID: `Env.schema.string()`,
+            AWS_SECRET_ACCESS_KEY: `Env.schema.string()`,
+            AWS_REGION: `Env.schema.string()`,
+            DYNAMODB_ENDPOINT: `Env.schema.string()`,
+        },
+        envVars: {
+            AWS_ACCESS_KEY_ID: '',
+            AWS_SECRET_ACCESS_KEY: '',
+            AWS_REGION: '',
+            DYNAMODB_ENDPOINT: '',
+        },
+    },
+};
+/**
+ * Configures the package
+ */
+export async function configure(command) {
+    const driver = await command.prompt.choice('Select the cache driver you plan to use', ['redis', 'file', 'memory', 'database', 'dynamodb'], {
+        hint: 'You can always change it later',
+    });
+    const { envVars, envValidations } = DRIVERS_INFO[driver];
+    const codemods = await command.createCodemods();
+    /**
+     * Publish provider
+     */
+    await codemods.updateRcFile((rcFile) => {
+        rcFile.addProvider('@adonisjs/cache/cache_provider').addCommand('@adonisjs/cache/commands');
+    });
+    /**
+     * Define environment variables
+     */
+    if (envVars) {
+        codemods.defineEnvVariables(envVars);
+    }
+    /**
+     * Define environment validations
+     */
+    if (envValidations) {
+        codemods.defineEnvValidations({ variables: envValidations });
+    }
+    /**
+     * Publish config
+     */
+    await command.publishStub('config.stub', { driver: driver });
+}

package/build/index.d.ts

@@ -0,0 +1,6 @@
+export { errors } from 'bentocache';
+export { configure } from './configure.js';
+export { stubsRoot } from './stubs/main.js';
+export { defineConfig } from './src/define_config.js';
+export { drivers } from './src/drivers.js';
+export { store } from './src/store.js';

package/build/index.js

@@ -0,0 +1,14 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export { errors } from 'bentocache';
+export { configure } from './configure.js';
+export { stubsRoot } from './stubs/main.js';
+export { defineConfig } from './src/define_config.js';
+export { drivers } from './src/drivers.js';
+export { store } from './src/store.js';

package/build/providers/cache_provider.d.ts

@@ -0,0 +1,42 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { CacheEvents } from 'bentocache/types';
+import type { CacheService } from '../src/types.js';
+/**
+ * Extend Adonis.js types to include cache
+ */
+declare module '@adonisjs/core/types' {
+    /**
+     * Adding cache type to the application container
+     */
+    interface ContainerBindings {
+        cache: CacheService;
+    }
+    /**
+     * Add cache events to the application events list
+     */
+    interface EventsList {
+        'cache:cleared': CacheEvents['cache:cleared'];
+        'cache:deleted': CacheEvents['cache:deleted'];
+        'cache:hit': CacheEvents['cache:hit'];
+        'cache:miss': CacheEvents['cache:miss'];
+        'cache:written': CacheEvents['cache:written'];
+        'bus:message:published': CacheEvents['bus:message:published'];
+        'bus:message:received': CacheEvents['bus:message:received'];
+    }
+}
+/**
+ * Cache provider to register cache specific bindings
+ */
+export default class CacheProvider {
+    #private;
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    /**
+     * Register bindings
+     */
+    register(): Promise<void>;
+    /**
+     * Disconnect all cache stores when shutting down the app
+     */
+    shutdown(): Promise<void>;
+}

package/build/providers/cache_provider.js

@@ -0,0 +1,64 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { defineReplBindings } from '../src/bindings/repl.js';
+/**
+ * Cache provider to register cache specific bindings
+ */
+export default class CacheProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    /**
+     * Register the cache manager to the container
+     */
+    async #registerCacheManager() {
+        const cacheConfig = this.app.config.get('cache');
+        this.app.container.singleton('cache', async () => {
+            const { BentoCache } = await import('bentocache');
+            const emitter = await this.app.container.make('emitter');
+            /**
+             * Resolve all store config providers
+             */
+            const resolvedStores = Object.entries(cacheConfig.stores).map(async ([name, store]) => {
+                return [name, await store.entry().resolver(this.app)];
+            });
+            return new BentoCache({
+                ...cacheConfig,
+                emitter: emitter,
+                default: cacheConfig.default,
+                stores: Object.fromEntries(await Promise.all(resolvedStores)),
+            });
+        });
+    }
+    /**
+     * Register REPL bindings
+     */
+    async #registerReplBindings() {
+        if (this.app.getEnvironment() !== 'repl') {
+            return;
+        }
+        const repl = await this.app.container.make('repl');
+        defineReplBindings(this.app, repl);
+    }
+    /**
+     * Register bindings
+     */
+    async register() {
+        this.#registerCacheManager();
+        this.#registerReplBindings();
+    }
+    /**
+     * Disconnect all cache stores when shutting down the app
+     */
+    async shutdown() {
+        const cache = await this.app.container.make('cache');
+        await cache.disconnectAll().catch(() => { });
+    }
+}

package/build/services/main.d.ts

@@ -0,0 +1,3 @@
+import type { CacheService } from '../src/types.js';
+declare let cache: CacheService;
+export { cache as default };

package/build/services/main.js

@@ -0,0 +1,17 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import app from '@adonisjs/core/services/app';
+let cache;
+/**
+ * Returns a singleton instance of the Cache manager
+ */
+await app.booted(async () => {
+    cache = await app.container.make('cache');
+});
+export { cache as default };

package/build/src/bindings/repl.d.ts

@@ -0,0 +1,6 @@
+import type { Repl } from '@adonisjs/core/repl';
+import type { ApplicationService } from '@adonisjs/core/types';
+/**
+ * Define REPL bindings
+ */
+export declare function defineReplBindings(app: ApplicationService, Repl: Repl): void;

package/build/src/bindings/repl.js

@@ -0,0 +1,28 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Helper to define REPL state
+ */
+function setupReplState(repl, key, value) {
+    repl.server.context[key] = value;
+    repl.notify(`Loaded ${key} module. You can access it using the "${repl.colors.underline(key)}" variable`);
+}
+/**
+ * Define REPL bindings
+ */
+export function defineReplBindings(app, Repl) {
+    /**
+     * Load cache provider to the cache property
+     */
+    Repl.addMethod('loadCache', async (repl) => {
+        setupReplState(repl, 'cache', await app.container.make('cache'));
+    }, {
+        description: 'Load cache provider to the "cache" property',
+    });
+}

package/build/src/define_config.d.ts

@@ -0,0 +1,12 @@
+import { Store } from './store.js';
+import { CacheOptions } from './types.js';
+/**
+ * Define cache configuration
+ */
+export declare function defineConfig<KnownCaches extends Record<string, Store>>(config: CacheOptions & {
+    default: keyof KnownCaches;
+    stores: KnownCaches;
+}): CacheOptions & {
+    default: keyof KnownCaches;
+    stores: KnownCaches;
+};

package/build/src/define_config.js

@@ -0,0 +1,14 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Define cache configuration
+ */
+export function defineConfig(config) {
+    return config;
+}

package/build/src/drivers.d.ts

@@ -0,0 +1,20 @@
+import type { ConfigProvider } from '@adonisjs/core/types';
+import type { RedisConnections } from '@adonisjs/redis/types';
+import { MemoryConfig, CreateDriverResult, L1CacheDriver, L2CacheDriver, CreateBusDriverResult, DynamoDBConfig, FileConfig } from 'bentocache/types';
+/**
+ * Different drivers supported by the cache module
+ */
+export declare const drivers: {
+    memory: (config: MemoryConfig) => ConfigProvider<CreateDriverResult<L1CacheDriver>>;
+    redis: (config: {
+        connectionName?: keyof RedisConnections;
+    }) => ConfigProvider<CreateDriverResult<L2CacheDriver>>;
+    redisBus: (config: {
+        connectionName?: keyof RedisConnections;
+    }) => ConfigProvider<CreateBusDriverResult>;
+    database: (config?: {
+        connectionName?: string;
+    }) => ConfigProvider<CreateDriverResult<L2CacheDriver>>;
+    dynamodb: (config: DynamoDBConfig) => ConfigProvider<CreateDriverResult<L2CacheDriver>>;
+    file: (config: FileConfig) => ConfigProvider<CreateDriverResult<L2CacheDriver>>;
+};

package/build/src/drivers.js

@@ -0,0 +1,101 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/// <reference types="@adonisjs/redis/redis_provider" />
+/// <reference types="@adonisjs/lucid/database_provider" />
+import { configProvider } from '@adonisjs/core';
+/**
+ * Different drivers supported by the cache module
+ */
+export const drivers = {
+    /**
+     * Redis driver for L2 layer
+     * You must install @adonisjs/redis to use this driver
+     */
+    redis(config) {
+        return configProvider.create(async (app) => {
+            const redis = await app.container.make('redis');
+            const { redisDriver } = await import('bentocache/drivers/redis');
+            const redisConnection = redis.connection(config.connectionName);
+            return redisDriver({ connection: redisConnection.ioConnection });
+        });
+    },
+    /**
+     * Redis driver for the sync bus
+     * You must install @adonisjs/redis to use this driver
+     */
+    redisBus(config) {
+        return configProvider.create(async (app) => {
+            const redis = await app.container.make('redis');
+            const { redisBusDriver } = await import('bentocache/drivers/redis');
+            const redisConnection = redis.connection(config.connectionName);
+            return redisBusDriver({ connection: redisConnection.ioConnection.options });
+        });
+    },
+    /**
+     * Memory driver for L1 layer
+     */
+    memory(config) {
+        return configProvider.create(async () => {
+            const { memoryDriver } = await import('bentocache/drivers/memory');
+            return memoryDriver(config);
+        });
+    },
+    /**
+     * Database driver for L2 layer
+     * You must install @adonisjs/lucid to use this driver
+     */
+    database(config) {
+        return configProvider.create(async (app) => {
+            const db = await app.container.make('lucid.db');
+            const connectionName = config?.connectionName || db.primaryConnectionName;
+            const dialect = db.connection(connectionName).dialect.name;
+            /**
+             * We only support pg, mysql, better-sqlite3 and sqlite3 dialects for now
+             */
+            const supportedDialects = ['pg', 'mysql', 'better-sqlite3', 'sqlite3'];
+            if (!supportedDialects.includes(dialect)) {
+                throw new Error(`Unsupported dialect "${dialect}"`);
+            }
+            /**
+             * Get the knex connection for the given connection name
+             */
+            const rawConnection = db.getRawConnection(connectionName);
+            if (!rawConnection?.connection?.client) {
+                throw new Error(`Unable to get raw connection for "${connectionName}"`);
+            }
+            /**
+             * Create the driver
+             */
+            const { knexDriver } = await import('bentocache/drivers/sql');
+            return knexDriver({
+                connection: rawConnection.connection.client,
+                dialect: dialect === 'postgres' ? 'pg' : dialect,
+            });
+        });
+    },
+    /**
+     * DynamoDB driver for L2 layer
+     * You must install @aws-sdk/client-dynamodb to use this driver
+     */
+    dynamodb(config) {
+        return configProvider.create(async () => {
+            const { dynamoDbDriver } = await import('bentocache/drivers/dynamodb');
+            return dynamoDbDriver(config);
+        });
+    },
+    /**
+     * File driver for L2 layer
+     */
+    file(config) {
+        return configProvider.create(async () => {
+            const { fileDriver } = await import('bentocache/drivers/file');
+            return fileDriver(config);
+        });
+    },
+};

package/build/src/store.d.ts

@@ -0,0 +1,46 @@
+import type { ConfigProvider } from '@adonisjs/core/types';
+import { RawCommonOptions, CreateDriverResult, L1CacheDriver, CreateBusDriverResult, L2CacheDriver } from 'bentocache/types';
+/**
+ * Create a new store
+ */
+export declare function store(options?: RawCommonOptions & {
+    prefix?: string;
+}): Store;
+export declare class Store {
+    #private;
+    constructor(baseOptions?: RawCommonOptions & {
+        prefix?: string;
+    });
+    /**
+     * Add a L1 layer to your store. This is usually a memory driver
+     * for fast access purposes.
+     */
+    useL1Layer(driver: ConfigProvider<CreateDriverResult<L1CacheDriver>>): this;
+    /**
+     * Add a L2 layer to your store. This is usually something
+     * distributed like Redis, DynamoDB, Sql database, etc.
+     */
+    useL2Layer(driver: ConfigProvider<CreateDriverResult<L2CacheDriver>>): this;
+    /**
+     * Add a bus to your store. It will be used to synchronize L1 layers between
+     * different instances of your application.
+     */
+    useBus(bus: ConfigProvider<CreateBusDriverResult>): this;
+    /**
+     * Create a config provider for the store
+     */
+    entry(): ConfigProvider<{
+        "__#70@#private": any;
+        useL1Layer(driver: CreateDriverResult<L1CacheDriver>): any;
+        useL2Layer(driver: CreateDriverResult<L2CacheDriver>): any;
+        useBus(bus: CreateBusDriverResult): any;
+        readonly entry: {
+            options: RawCommonOptions & {
+                prefix?: string | undefined;
+            };
+            l1: CreateDriverResult<L1CacheDriver> | undefined;
+            l2: CreateDriverResult<L2CacheDriver> | undefined;
+            bus: CreateBusDriverResult | undefined;
+        };
+    }>;
+}

package/build/src/store.js

@@ -0,0 +1,64 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { bentostore } from 'bentocache';
+import { configProvider } from '@adonisjs/core';
+/**
+ * Create a new store
+ */
+export function store(options) {
+    return new Store(options);
+}
+export class Store {
+    #baseOptions = {};
+    #l1;
+    #l2;
+    #bus;
+    constructor(baseOptions = {}) {
+        this.#baseOptions = baseOptions;
+    }
+    /**
+     * Add a L1 layer to your store. This is usually a memory driver
+     * for fast access purposes.
+     */
+    useL1Layer(driver) {
+        this.#l1 = driver;
+        return this;
+    }
+    /**
+     * Add a L2 layer to your store. This is usually something
+     * distributed like Redis, DynamoDB, Sql database, etc.
+     */
+    useL2Layer(driver) {
+        this.#l2 = driver;
+        return this;
+    }
+    /**
+     * Add a bus to your store. It will be used to synchronize L1 layers between
+     * different instances of your application.
+     */
+    useBus(bus) {
+        this.#bus = bus;
+        return this;
+    }
+    /**
+     * Create a config provider for the store
+     */
+    entry() {
+        return configProvider.create(async (app) => {
+            const storeInstance = bentostore(this.#baseOptions);
+            if (this.#l1)
+                storeInstance.useL1Layer(await this.#l1?.resolver(app));
+            if (this.#l2)
+                storeInstance.useL2Layer(await this.#l2?.resolver(app));
+            if (this.#bus)
+                storeInstance.useBus(await this.#bus?.resolver(app));
+            return storeInstance;
+        });
+    }
+}

package/build/src/types.d.ts

@@ -0,0 +1,26 @@
+import type { BentoCache, bentostore } from 'bentocache';
+import type { RawBentoCacheOptions } from 'bentocache/types';
+import type { store } from './store.js';
+/**
+ * The options accepted by the cache module
+ */
+export type CacheOptions = Omit<RawBentoCacheOptions, 'logger' | 'emitter'>;
+/**
+ * Infer the stores from the user config
+ */
+export type InferStores<T extends {
+    stores: Record<string, ReturnType<typeof store>>;
+}> = {
+    [K in keyof T['stores']]: any;
+};
+/**
+ * A list of known caches stores inferred from the user config
+ * This interface must be extended in user-land
+ */
+export interface CacheStores {
+}
+/**
+ * The cache service interface registered with the container
+ */
+export interface CacheService extends BentoCache<CacheStores extends Record<string, ReturnType<typeof bentostore>> ? CacheStores : never> {
+}

package/build/src/types.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};

package/build/stubs/config.stub

@@ -0,0 +1,45 @@
+{{{
+  exports({ to: app.configPath('cache.ts') })
+}}}
+import env from '#start/env'
+{{#if driver === 'file'}}
+import app from '@adonisjs/core/services/app'
+{{/if}}
+import { defineConfig, store, drivers } from '@adonisjs/cache'
+
+const cacheConfig = defineConfig({
+  default: '{{ driver }}',
+  stores: {
+    {{#if driver === 'database'}}
+    database: store().useL2Layer(drivers.database({
+      connectionName: 'primary',
+    }))
+    {{#elif driver === 'redis'}}
+    redis: store().useL2Layer(drivers.redis({
+      connectionName: 'primary',
+    }))
+    {{#elif driver === 'memory'}}
+    memory: store().useL1Layer(drivers.memory())
+    {{#elif driver === 'file'}}
+    file: store().useL2Layer(drivers.file({
+      directory: app.tmpPath('cache')
+    }))
+    {{#elif driver === 'dynamodb'}}
+    dynamodb: store().useL2Layer(drivers.dynamodb({
+      table: { name: 'cache' },
+      credentials: {
+        accessKeyId: env.get('AWS_ACCESS_KEY_ID'),
+        secretAccessKey: env.get('AWS_SECRET_ACCESS_KEY')
+      },
+      region: env.get('AWS_REGION'),
+      endpoint: env.get('DYNAMODB_ENDPOINT')
+    }))
+    {{/if}}
+  }
+})
+
+export default cacheConfig
+
+declare module '@adonisjs/cache/types' {
+  interface CacheStores extends InferStores<typeof cacheConfig> {}
+}

package/build/stubs/main.d.ts

@@ -0,0 +1 @@
+export declare const stubsRoot: string;

package/build/stubs/main.js

@@ -0,0 +1,10 @@
+/*
+ * @adonisjs/cache
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { getDirname } from '@poppinss/utils';
+export const stubsRoot = getDirname(import.meta.url);

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@adonisjs/cache",
+  "description": "Official caching module for AdonisJS framework",
+  "version": "1.0.0-0",
+  "engines": {
+    "node": ">=18.16.0"
+  },
+  "main": "build/index.js",
+  "type": "module",
+  "files": [
+    "build/configure.js",
+    "build/configure.d.ts",
+    "build/index.js",
+    "build/index.d.ts",
+    "build/factories",
+    "build/providers",
+    "build/services",
+    "build/commands",
+    "build/src",
+    "build/stubs"
+  ],
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/src/types.js",
+    "./commands/*": "./build/commands/*.js",
+    "./commands": "./build/commands/main.js",
+    "./services/main": "./build/services/main.js",
+    "./cache_provider": "./build/providers/cache_provider.js"
+  },
+  "scripts": {
+    "clean": "del-cli build",
+    "copy:templates": "copyfiles \"stubs/**/*.stub\" build",
+    "typecheck": "tsc --noEmit",
+    "index:commands": "adonis-kit index build/commands",
+    "lint": "eslint . --ext=.ts",
+    "format": "prettier --write .",
+    "quick:test": "node --enable-source-maps --loader=ts-node/esm bin/test.ts",
+    "pretest": "npm run lint",
+    "test": "c8 npm run quick:test",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "tsc",
+    "postbuild": "npm run copy:templates && npm run index:commands",
+    "release": "np",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@adonisjs/assembler": "^6.1.3-25",
+    "@adonisjs/core": "^6.1.5-29",
+    "@adonisjs/eslint-config": "^1.1.8",
+    "@adonisjs/lucid": "19.0.0-3",
+    "@adonisjs/prettier-config": "^1.1.8",
+    "@adonisjs/redis": "8.0.0-12",
+    "@adonisjs/tsconfig": "^1.1.8",
+    "@japa/assert": "2.0.1",
+    "@japa/expect-type": "^2.0.0",
+    "@japa/file-system": "^2.0.1",
+    "@japa/runner": "^3.0.5",
+    "@japa/snapshot": "^2.0.1",
+    "@swc/core": "^1.3.96",
+    "@types/node": "^20.8.10",
+    "better-sqlite3": "^9.0.0",
+    "c8": "^8.0.1",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.53.0",
+    "ioredis": "^5.3.2",
+    "luxon": "^3.4.3",
+    "np": "^8.0.4",
+    "p-event": "^6.0.0",
+    "prettier": "^3.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "@poppinss/utils": "^6.5.1",
+    "bentocache": "1.0.0-beta.4"
+  },
+  "peerDependencies": {
+    "@adonisjs/assembler": "^6.1.3-22",
+    "@adonisjs/core": "^6.1.5-26",
+    "@adonisjs/lucid": "19.0.0-3",
+    "@adonisjs/redis": "8.0.0-12"
+  },
+  "peerDependenciesMeta": {
+    "@adonisjs/assembler": {
+      "optional": true
+    },
+    "@adonisjs/redis": {
+      "optional": true
+    },
+    "@adonisjs/lucid": {
+      "optional": true
+    }
+  },
+  "author": "adonisjs, Julien Ripouteau",
+  "license": "MIT",
+  "keywords": [
+    "adonisjs",
+    "cache",
+    "caching",
+    "bentocache"
+  ],
+  "eslintConfig": {
+    "extends": "@adonisjs/eslint-config/package"
+  },
+  "prettier": "@adonisjs/prettier-config",
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "latest",
+    "branch": "main",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
+  }
+}