@ruiapp/rapid-core 0.5.9 → 0.5.11

package/dist/core/facility.d.ts

@@ -1,5 +1,5 @@
 import { IRpdServer } from "./server";
-export interface FacilityFactory {
+export interface FacilityFactory<TFacility = any, TCreateFacilityOptions = any> {
     name: string;
-    createFacility: (server: IRpdServer, options?: any) => Promise<any>;
+    createFacility: (server: IRpdServer, options?: TCreateFacilityOptions) => Promise<TFacility>;
 }

package/dist/core/server.d.ts

@@ -10,7 +10,7 @@ export interface IRpdServer {
     queryBuilder: IQueryBuilder;
     getLogger(): Logger;
     registerFacilityFactory(factory: FacilityFactory): any;
-    getFacility<TFacility = any>(name: string, options?: any): Promise<TFacility>;
+    getFacility<TFacility = any, TOptions = any>(name: string, options?: TOptions): Promise<TFacility>;
     getDatabaseAccessor(): IDatabaseAccessor;
     queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient) => Promise<any[]>;
     tryQueryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient) => Promise<any[]>;

package/dist/facilities/cache/CacheFacilityTypes.d.ts

@@ -1,4 +1,12 @@
+import { IRpdServer } from "../../core/server";
+export interface CacheFactoryConfig {
+    providers?: CacheProvider[];
+}
 export interface CacheProvider {
+    providerName: string;
+    createCache: (server: IRpdServer) => Promise<Cache>;
+}
+export interface Cache {
     set: (key: string, value: any, options?: SetValueOptions) => Promise<void>;
     get: (key: string) => Promise<any>;
     del: (key: string) => Promise<void>;
@@ -9,3 +17,6 @@ export interface SetValueOptions {
      */
     ttl?: number;
 }
+export interface CreateCacheFacilityOptions {
+    providerName: string;
+}

package/dist/facilities/cache/CacheFactory.d.ts

@@ -1,8 +1,9 @@
 import { FacilityFactory } from "../../core/facility";
 import { IRpdServer } from "../../core/server";
-import MemoryCache from "./MemoryCache";
-export default class CacheFactory implements FacilityFactory {
+import { Cache, CacheFactoryConfig, CreateCacheFacilityOptions } from "./CacheFacilityTypes";
+export default class CacheFactory implements FacilityFactory<Cache, CreateCacheFacilityOptions> {
+    #private;
     readonly name: string;
-    constructor();
-    createFacility(server: IRpdServer, options?: any): Promise<MemoryCache>;
+    constructor(config: CacheFactoryConfig);
+    createFacility(server: IRpdServer, options?: CreateCacheFacilityOptions): Promise<Cache>;
 }

package/dist/facilities/cache/MemoryCache.d.ts

@@ -1,9 +1,9 @@
-import { CacheProvider, SetValueOptions } from "./CacheFacilityTypes";
+import { Cache, SetValueOptions } from "./CacheFacilityTypes";
 export type MemoryCacheItem<TValue = any> = {
     value: TValue;
     expireAt: number;
 };
-export default class MemoryCache implements CacheProvider {
+export default class MemoryCache implements Cache {
     set(key: string, value: any, options?: SetValueOptions): Promise<void>;
     get(key: string): Promise<any>;
     del(key: string): Promise<void>;

package/dist/facilities/cache/MemoryCacheProvider.d.ts

@@ -0,0 +1,8 @@
+import MemoryCache from "./MemoryCache";
+import { CacheProvider } from "./CacheFacilityTypes";
+import { IRpdServer } from "../../core/server";
+export default class MemoryCacheProvider implements CacheProvider {
+    readonly providerName: string;
+    constructor();
+    createCache(server: IRpdServer): Promise<MemoryCache>;
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./types";
 export * from "./server";
+export * from "./core/facility";
 export * from "./core/request";
 export * from "./core/routeContext";
 export * from "./core/server";

package/dist/index.js

@@ -4684,13 +4684,35 @@ class MemoryCache {
     }
 }
 
+class MemoryCacheProvider {
+    providerName;
+    constructor() {
+        this.providerName = "memory";
+    }
+    async createCache(server) {
+        return new MemoryCache();
+    }
+}
+
 class CacheFactory {
     name;
-    constructor() {
+    #providers;
+    constructor(config) {
         this.name = "cache";
+        const memoryCacheCreator = new MemoryCacheProvider();
+        this.#providers = new Map();
+        this.#providers.set(memoryCacheCreator.providerName, memoryCacheCreator);
+        for (const provider of config.providers) {
+            this.#providers.set(provider.providerName, provider);
+        }
     }
     async createFacility(server, options) {
-        return new MemoryCache();
+        const providerName = options?.providerName || "memory";
+        const creator = this.#providers.get(providerName);
+        if (!creator) {
+            throw new Error(`Unkown cache provider name: ${providerName}`);
+        }
+        return creator.createCache(server);
     }
 }
 

package/dist/server.d.ts

@@ -40,7 +40,7 @@ export declare class RapidServer implements IRpdServer {
     start(): Promise<void>;
     configureApplication(): Promise<void>;
     registerFacilityFactory(factory: FacilityFactory): void;
-    getFacility<TFacility = any>(name: string, options?: any, nullIfUnknownFacility?: boolean): Promise<TFacility>;
+    getFacility<TFacility = any, TOptions = any>(name: string, options?: TOptions, nullIfUnknownFacility?: boolean): Promise<TFacility>;
     queryDatabaseObject(sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient): Promise<any[]>;
     tryQueryDatabaseObject(sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient): Promise<any[]>;
     get middlewares(): any[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/facility.ts

@@ -1,7 +1,7 @@
 import { IRpdServer } from "./server";
 
-export interface FacilityFactory {
+export interface FacilityFactory<TFacility = any, TCreateFacilityOptions = any> {
   name: string;
 
-  createFacility: (server: IRpdServer, options?: any) => Promise<any>;
+  createFacility: (server: IRpdServer, options?: TCreateFacilityOptions) => Promise<TFacility>;
 }

package/src/core/server.ts

@@ -30,7 +30,7 @@ export interface IRpdServer {
 
   registerFacilityFactory(factory: FacilityFactory);
 
-  getFacility<TFacility = any>(name: string, options?: any): Promise<TFacility>;
+  getFacility<TFacility = any, TOptions = any>(name: string, options?: TOptions): Promise<TFacility>;
 
   getDatabaseAccessor(): IDatabaseAccessor;
   queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient) => Promise<any[]>;

package/src/facilities/cache/CacheFacilityTypes.ts

@@ -1,4 +1,15 @@
+import { IRpdServer } from "~/core/server";
+
+export interface CacheFactoryConfig {
+  providers?: CacheProvider[];
+}
+
 export interface CacheProvider {
+  providerName: string;
+  createCache: (server: IRpdServer) => Promise<Cache>;
+}
+
+export interface Cache {
   set: (key: string, value: any, options?: SetValueOptions) => Promise<void>;
   get: (key: string) => Promise<any>;
   del: (key: string) => Promise<void>;
@@ -10,3 +21,7 @@ export interface SetValueOptions {
    */
   ttl?: number;
 }
+
+export interface CreateCacheFacilityOptions {
+  providerName: string;
+}

package/src/facilities/cache/CacheFactory.ts

@@ -1,15 +1,31 @@
 import { FacilityFactory } from "~/core/facility";
 import { IRpdServer } from "~/core/server";
-import MemoryCache from "./MemoryCache";
+import { Cache, CacheProvider, CacheFactoryConfig, CreateCacheFacilityOptions } from "./CacheFacilityTypes";
+import MemoryCacheProvider from "./MemoryCacheProvider";
 
-export default class CacheFactory implements FacilityFactory {
+export default class CacheFactory implements FacilityFactory<Cache, CreateCacheFacilityOptions> {
   readonly name: string;
+  #providers: Map<string, CacheProvider>;
 
-  constructor() {
+  constructor(config: CacheFactoryConfig) {
     this.name = "cache";
+
+    const memoryCacheCreator = new MemoryCacheProvider();
+
+    this.#providers = new Map();
+    this.#providers.set(memoryCacheCreator.providerName, memoryCacheCreator);
+
+    for (const provider of config.providers) {
+      this.#providers.set(provider.providerName, provider);
+    }
   }
 
-  async createFacility(server: IRpdServer, options?: any) {
-    return new MemoryCache();
+  async createFacility(server: IRpdServer, options?: CreateCacheFacilityOptions) {
+    const providerName = options?.providerName || "memory";
+    const creator = this.#providers.get(providerName);
+    if (!creator) {
+      throw new Error(`Unkown cache provider name: ${providerName}`);
+    }
+    return creator.createCache(server);
   }
 }

package/src/facilities/cache/MemoryCache.ts

@@ -1,4 +1,4 @@
-import { CacheProvider, SetValueOptions } from "./CacheFacilityTypes";
+import { Cache, SetValueOptions } from "./CacheFacilityTypes";
 
 export type MemoryCacheItem<TValue = any> = {
   value: TValue;
@@ -7,7 +7,7 @@ export type MemoryCacheItem<TValue = any> = {
 
 const values: Map<string, MemoryCacheItem> = new Map();
 
-export default class MemoryCache implements CacheProvider {
+export default class MemoryCache implements Cache {
   async set(key: string, value: any, options?: SetValueOptions) {
     let expireAt = -1;
     if (options && options.ttl > 0) {

package/src/facilities/cache/MemoryCacheProvider.ts

@@ -0,0 +1,15 @@
+import MemoryCache from "./MemoryCache";
+import { CacheProvider } from "./CacheFacilityTypes";
+import { IRpdServer } from "~/core/server";
+
+export default class MemoryCacheProvider implements CacheProvider {
+  readonly providerName: string;
+
+  constructor() {
+    this.providerName = "memory";
+  }
+
+  async createCache(server: IRpdServer) {
+    return new MemoryCache();
+  }
+}

package/src/index.ts

@@ -4,6 +4,7 @@ fixBigIntJSONSerialize();
 export * from "./types";
 export * from "./server";
 
+export * from "./core/facility";
 export * from "./core/request";
 export * from "./core/routeContext";
 export * from "./core/server";

package/src/server.ts

@@ -361,7 +361,7 @@ export class RapidServer implements IRpdServer {
     this.#facilityFactories.set(factory.name, factory);
   }
 
-  async getFacility<TFacility = any>(name: string, options?: any, nullIfUnknownFacility?: boolean): Promise<TFacility> {
+  async getFacility<TFacility = any, TOptions = any>(name: string, options?: TOptions, nullIfUnknownFacility?: boolean): Promise<TFacility> {
     const factory = this.#facilityFactories.get(name);
     if (!factory) {
       if (nullIfUnknownFacility) {