strapi-cache 1.6.2 → 1.7.0

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default bootstrap;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,27 @@
+declare const _default: {
+    default: ({ env }: {
+        env: any;
+    }) => {
+        debug: boolean;
+        max: number;
+        ttl: number;
+        size: number;
+        allowStale: boolean;
+        cacheableRoutes: any[];
+        provider: string;
+        excludeRoutes: any[];
+        redisConfig: any;
+        redisClusterNodes: any[];
+        redisClusterOptions: {};
+        cacheHeaders: boolean;
+        cacheHeadersDenyList: any[];
+        cacheHeadersAllowList: any[];
+        cacheAuthorizedRequests: boolean;
+        cacheGetTimeoutInMs: number;
+        autoPurgeCache: boolean;
+        autoPurgeCacheOnStart: boolean;
+        disableAdminPopups: boolean;
+    };
+    validator: (config: any) => void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/controllers/controller.d.ts

@@ -0,0 +1,10 @@
+import type { Core } from '@strapi/strapi';
+import { Context } from 'koa';
+declare const controller: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    purgeCache(ctx: Context): Promise<void>;
+    purgeCacheByKey(ctx: Context): Promise<void>;
+    config(ctx: Context): Promise<void>;
+};
+export default controller;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="koa" />
+declare const _default: {
+    controller: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        purgeCache(ctx: import("koa").Context): Promise<void>;
+        purgeCacheByKey(ctx: import("koa").Context): Promise<void>;
+        config(ctx: import("koa").Context): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/index.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="koa" />
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    destroy(): void;
+    config: {
+        default: ({ env }: {
+            env: any;
+        }) => {
+            debug: boolean;
+            max: number;
+            ttl: number;
+            size: number;
+            allowStale: boolean;
+            cacheableRoutes: any[];
+            provider: string;
+            excludeRoutes: any[];
+            redisConfig: any;
+            redisClusterNodes: any[];
+            redisClusterOptions: {};
+            cacheHeaders: boolean;
+            cacheHeadersDenyList: any[];
+            cacheHeadersAllowList: any[];
+            cacheAuthorizedRequests: boolean;
+            cacheGetTimeoutInMs: number;
+            autoPurgeCache: boolean;
+            autoPurgeCacheOnStart: boolean;
+            disableAdminPopups: boolean;
+        };
+        validator: (config: any) => void;
+    };
+    controllers: {
+        controller: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            purgeCache(ctx: import("koa").Context): Promise<void>;
+            purgeCacheByKey(ctx: import("koa").Context): Promise<void>;
+            config(ctx: import("koa").Context): Promise<void>;
+        };
+    };
+    routes: {
+        'purge-route': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+    services: {
+        service: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => import("./types/cache.types").CacheService;
+    };
+    contentTypes: {};
+    policies: {};
+    middlewares: {
+        graphql: (ctx: any, next: any) => Promise<void>;
+        cache: (ctx: import("koa").Context, next: any) => Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/middlewares/cache.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koa';
+declare const middleware: (ctx: Context, next: any) => Promise<void>;
+export default middleware;

package/dist/server/src/middlewares/graphql.d.ts

@@ -0,0 +1,2 @@
+declare const middleware: (ctx: any, next: any) => Promise<void>;
+export default middleware;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="koa" />
+declare const _default: {
+    graphql: (ctx: any, next: any) => Promise<void>;
+    cache: (ctx: import("koa").Context, next: any) => Promise<void>;
+};
+export default _default;

package/dist/server/src/permissions.d.ts

@@ -0,0 +1,6 @@
+export declare const actions: {
+    section: string;
+    displayName: string;
+    uid: string;
+    pluginName: string;
+}[];

package/dist/server/src/policies/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,19 @@
+declare const routes: {
+    'purge-route': {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+};
+export default routes;

package/dist/server/src/routes/purge.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    method: string;
+    path: string;
+    handler: string;
+    config: {
+        policies: (string | {
+            name: string;
+            config: {
+                actions: string[];
+            };
+        })[];
+    };
+}[];
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,8 @@
+import type { Core } from '@strapi/strapi';
+import { CacheService } from '../../src/types/cache.types';
+declare const _default: {
+    service: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => CacheService;
+};
+export default _default;

package/dist/server/src/services/memory/provider.d.ts

@@ -0,0 +1,17 @@
+import type { Core } from '@strapi/strapi';
+import { CacheProvider } from '../../types/cache.types';
+export declare class InMemoryCacheProvider implements CacheProvider {
+    private strapi;
+    private initialized;
+    private provider;
+    private cacheGetTimeoutInMs;
+    constructor(strapi: Core.Strapi);
+    init(): void;
+    get ready(): boolean;
+    get(key: string): Promise<any | null>;
+    set(key: string, val: any): Promise<any | null>;
+    del(key: string): Promise<any | null>;
+    keys(): Promise<string[] | null>;
+    reset(): Promise<any | null>;
+    clearByRegexp(regExps: RegExp[]): Promise<void>;
+}

package/dist/server/src/services/memory/service.d.ts

@@ -0,0 +1,6 @@
+import type { Core } from '@strapi/strapi';
+import type { CacheService } from '../../types/cache.types';
+declare const service: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => CacheService;
+export default service;

package/dist/server/src/services/redis/provider.d.ts

@@ -0,0 +1,18 @@
+import type { Core } from '@strapi/strapi';
+import { CacheProvider } from '../../types/cache.types';
+export declare class RedisCacheProvider implements CacheProvider {
+    private strapi;
+    private initialized;
+    private client;
+    private cacheGetTimeoutInMs;
+    private keyPrefix;
+    constructor(strapi: Core.Strapi);
+    init(): void;
+    get ready(): boolean;
+    get(key: string): Promise<any | null>;
+    set(key: string, val: any): Promise<any | null>;
+    del(key: string): Promise<any | null>;
+    keys(): Promise<string[] | null>;
+    reset(): Promise<any | null>;
+    clearByRegexp(regExps: RegExp[]): Promise<void>;
+}

package/dist/server/src/services/redis/service.d.ts

@@ -0,0 +1,6 @@
+import type { Core } from '@strapi/strapi';
+import type { CacheService } from '../../types/cache.types';
+declare const service: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => CacheService;
+export default service;

package/dist/server/src/services/resolver.d.ts

@@ -0,0 +1,3 @@
+import type { Core } from '@strapi/strapi';
+import { CacheProvider } from '../../src/types/cache.types';
+export declare const resolveCacheProvider: (strapi: Core.Strapi) => CacheProvider;

package/dist/server/src/types/cache.types.d.ts

@@ -0,0 +1,18 @@
+import type { LRUCache } from 'lru-cache';
+export interface CacheProvider {
+    init(): void;
+    get(key: string): Promise<any | null>;
+    set(key: string, val: any): Promise<any | null>;
+    del(key: string): Promise<any | null>;
+    keys(): Promise<string[] | null>;
+    reset(): Promise<any | null>;
+    readonly ready: boolean;
+    clearByRegexp(regExps: RegExp[]): Promise<void>;
+}
+export interface CacheService {
+    getCacheInstance(): CacheProvider;
+}
+export interface CacheInstance {
+    initialized: boolean;
+    provider: LRUCache<string, any>;
+}

package/dist/server/src/utils/body.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Stream } from 'stream';
+export declare const streamToBuffer: (stream: Stream) => Promise<Buffer>;
+export declare const decompressBuffer: (buffer: Buffer, encoding?: string) => Promise<Buffer>;
+export declare const decodeBufferToText: (buffer: Buffer) => string;

package/dist/server/src/utils/header.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Context } from 'koa';
+import { OutgoingHttpHeaders } from 'http';
+export declare function getHeadersToStore(ctx: Context, cacheHeaders: boolean, cacheHeadersAllowList?: string[], cacheHeadersDenyList?: string[]): OutgoingHttpHeaders | null;
+export declare function getCacheHeaderConfig(): {
+    cacheHeaders: boolean;
+    cacheHeadersDenyList: string[];
+    cacheHeadersAllowList: string[];
+    cacheAuthorizedRequests: boolean;
+};

package/dist/server/src/utils/invalidateCache.d.ts

@@ -0,0 +1,4 @@
+import { Core } from '@strapi/strapi';
+import { CacheProvider } from 'src/types/cache.types';
+export declare function invalidateCache(event: any, cacheStore: CacheProvider, strapi: Core.Strapi): Promise<void>;
+export declare function invalidateGraphqlCache(cacheStore: CacheProvider): Promise<void>;

package/dist/server/src/utils/key.d.ts

@@ -0,0 +1,4 @@
+import { Context } from 'koa';
+export declare const generateCacheKey: (context: Context) => string;
+export declare const generateGraphqlCacheKey: (payload: string) => string;
+export declare const escapeRegExp: (s: string) => string;

package/dist/server/src/utils/log.d.ts

@@ -0,0 +1,5 @@
+export declare const loggy: {
+    info: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+};

package/dist/server/src/utils/withTimeout.d.ts

@@ -0,0 +1 @@
+export declare const withTimeout: (callback: () => Promise<any>, ms: number) => Promise<any>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.6.2",
+  "version": "1.7.0",
   "keywords": [
     "strapi cache",
     "strapi rest cache",