@ruiapp/rapid-core 0.5.10 → 0.5.12

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,6 +1,16 @@
+import { IRpdServer } from "../../core/server";
+export interface CacheFactoryConfig {
+    providers?: CacheProvider[];
+}
 export interface CacheProvider {
-    set: (key: string, value: any, options?: SetValueOptions) => Promise<void>;
-    get: (key: string) => Promise<any>;
+    providerName: string;
+    createCache: (server: IRpdServer) => Promise<Cache>;
+}
+export interface Cache {
+    set: (key: string, value: string, options?: SetValueOptions) => Promise<void>;
+    setObject: (key: string, value: Record<string, any>, options?: SetValueOptions) => Promise<void>;
+    get: (key: string) => Promise<string | null>;
+    getObject: (key: string) => Promise<Record<string, any> | null>;
     del: (key: string) => Promise<void>;
 }
 export interface SetValueOptions {
@@ -9,3 +19,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,10 +1,12 @@
-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 {
-    set(key: string, value: any, options?: SetValueOptions): Promise<void>;
+export default class MemoryCache implements Cache {
+    set(key: string, value: string, options?: SetValueOptions): Promise<void>;
+    setObject(key: string, value: Record<string, any>, options?: SetValueOptions): Promise<void>;
     get(key: string): Promise<any>;
+    getObject(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

@@ -6,7 +6,10 @@ export * from "./core/routeContext";
 export * from "./core/server";
 export * from "./core/http-types";
 export * from "./core/actionHandler";
+export * from "./utilities/accessControlUtility";
+export * from "./utilities/entityUtility";
 export * from "./utilities/jwtUtility";
+export * from "./utilities/timeUtility";
 export * from "./deno-std/http/cookie";
 export { mapDbRowToEntity } from "./dataAccess/entityMapper";
 export * as bootstrapApplicationConfig from "./bootstrapApplicationConfig";

package/dist/index.js

@@ -2509,6 +2509,9 @@ function getEntityPartChanges(server, model, before, after) {
     return null;
 }
 
+function getNowString() {
+    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSS");
+}
 function getNowStringWithTimezone() {
     return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSSZ");
 }
@@ -4511,6 +4514,46 @@ class RapidServer {
     }
 }
 
+function isAccessAllowed(policy, allowedActions) {
+    let isAnyCheckPassed = true;
+    let isAllCheckPassed = true;
+    if (policy.any) {
+        isAnyCheckPassed = false;
+        for (const action of policy.any) {
+            if (lodash.find(allowedActions, (item) => item === action) != null) {
+                isAnyCheckPassed = true;
+                break;
+            }
+        }
+    }
+    if (policy.all) {
+        isAllCheckPassed = true;
+        for (const action of policy.all) {
+            if (lodash.find(allowedActions, (item) => item === action) == null) {
+                isAnyCheckPassed = false;
+                break;
+            }
+        }
+    }
+    return isAnyCheckPassed && isAllCheckPassed;
+}
+
+function getEntityRelationTargetId(entity, propName, targetColumnName) {
+    if (!entity) {
+        throw new Error(`"entity" parameter is required.`);
+    }
+    let targetId = entity[propName];
+    if (!targetId && targetColumnName) {
+        targetId = entity[targetColumnName];
+    }
+    if (lodash.isObject(targetId)) {
+        return targetId.id;
+    }
+    else {
+        return targetId;
+    }
+}
+
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 /**
@@ -4655,42 +4698,76 @@ async function generateJwtSecretKey() {
 }
 
 const values = new Map();
+async function set(key, value, options) {
+    let expireAt = -1;
+    if (options && options.ttl > 0) {
+        expireAt = new Date().valueOf() + options.ttl;
+    }
+    const cacheItem = {
+        value,
+        expireAt,
+    };
+    values.set(key, cacheItem);
+}
+async function get(key) {
+    const cacheItem = values.get(key);
+    if (cacheItem) {
+        if (cacheItem.expireAt === -1) {
+            return cacheItem.value;
+        }
+        if (cacheItem.expireAt >= new Date().valueOf()) {
+            return cacheItem.value;
+        }
+    }
+    return undefined;
+}
 class MemoryCache {
     async set(key, value, options) {
-        let expireAt = -1;
-        if (options && options.ttl > 0) {
-            expireAt = new Date().valueOf() + options.ttl;
-        }
-        const cacheItem = {
-            value,
-            expireAt,
-        };
-        values.set(key, cacheItem);
+        await set(key, value, options);
+    }
+    async setObject(key, value, options) {
+        await set(key, value, options);
     }
     async get(key) {
-        const cacheItem = values.get(key);
-        if (cacheItem) {
-            if (cacheItem.expireAt === -1) {
-                return cacheItem.value;
-            }
-            if (cacheItem.expireAt >= new Date().valueOf()) {
-                return cacheItem.value;
-            }
-        }
-        return undefined;
+        return get(key);
+    }
+    async getObject(key) {
+        return get(key);
     }
     async del(key) {
         values.delete(key);
     }
 }
 
+class MemoryCacheProvider {
+    providerName;
+    constructor() {
+        this.providerName = "memory";
+    }
+    async createCache(server) {
+        return new MemoryCache();
+    }
+}
+
 class CacheFactory {
     name;
-    constructor() {
+    #providers;
+    constructor(config) {
         this.name = "cache";
+        const memoryCacheProvider = new MemoryCacheProvider();
+        this.#providers = new Map();
+        this.#providers.set(memoryCacheProvider.providerName, memoryCacheProvider);
+        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);
     }
 }
 
@@ -8569,30 +8646,6 @@ function getStateMachineCode(model, property) {
     }
 }
 
-function isAccessAllowed(policy, allowedActions) {
-    let isAnyCheckPassed = true;
-    let isAllCheckPassed = true;
-    if (policy.any) {
-        isAnyCheckPassed = false;
-        for (const action of policy.any) {
-            if (lodash.find(allowedActions, (item) => item === action) != null) {
-                isAnyCheckPassed = true;
-                break;
-            }
-        }
-    }
-    if (policy.all) {
-        isAllCheckPassed = true;
-        for (const action of policy.all) {
-            if (lodash.find(allowedActions, (item) => item === action) == null) {
-                isAnyCheckPassed = false;
-                break;
-            }
-        }
-    }
-    return isAnyCheckPassed && isAllCheckPassed;
-}
-
 class EntityAccessControlPlugin {
     constructor() { }
     get code() {
@@ -8740,7 +8793,11 @@ exports.decodeJwt = decodeJwt;
 exports.deleteCookie = deleteCookie;
 exports.generateJwtSecretKey = generateJwtSecretKey;
 exports.getCookies = getCookies;
+exports.getEntityRelationTargetId = getEntityRelationTargetId;
+exports.getNowString = getNowString;
+exports.getNowStringWithTimezone = getNowStringWithTimezone;
 exports.getSetCookies = getSetCookies;
+exports.isAccessAllowed = isAccessAllowed;
 exports.mapDbRowToEntity = mapDbRowToEntity;
 exports.setCookie = setCookie;
 exports.verifyJwt = verifyJwt;

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/dist/utilities/entityUtility.d.ts

@@ -0,0 +1 @@
+export declare function getEntityRelationTargetId(entity: Record<string, any>, propName: string, targetColumnName?: string): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "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,6 +1,19 @@
+import { IRpdServer } from "~/core/server";
+
+export interface CacheFactoryConfig {
+  providers?: CacheProvider[];
+}
+
 export interface CacheProvider {
-  set: (key: string, value: any, options?: SetValueOptions) => Promise<void>;
-  get: (key: string) => Promise<any>;
+  providerName: string;
+  createCache: (server: IRpdServer) => Promise<Cache>;
+}
+
+export interface Cache {
+  set: (key: string, value: string, options?: SetValueOptions) => Promise<void>;
+  setObject: (key: string, value: Record<string, any>, options?: SetValueOptions) => Promise<void>;
+  get: (key: string) => Promise<string | null>;
+  getObject: (key: string) => Promise<Record<string, any> | null>;
   del: (key: string) => Promise<void>;
 }
 
@@ -10,3 +23,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 memoryCacheProvider = new MemoryCacheProvider();
+
+    this.#providers = new Map();
+    this.#providers.set(memoryCacheProvider.providerName, memoryCacheProvider);
+
+    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,33 +7,49 @@ export type MemoryCacheItem<TValue = any> = {
 
 const values: Map<string, MemoryCacheItem> = new Map();
 
-export default class MemoryCache implements CacheProvider {
-  async set(key: string, value: any, options?: SetValueOptions) {
-    let expireAt = -1;
-    if (options && options.ttl > 0) {
-      expireAt = new Date().valueOf() + options.ttl;
+async function set(key: string, value: any, options?: SetValueOptions) {
+  let expireAt = -1;
+  if (options && options.ttl > 0) {
+    expireAt = new Date().valueOf() + options.ttl;
+  }
+
+  const cacheItem = {
+    value,
+    expireAt,
+  };
+  values.set(key, cacheItem);
+}
+
+async function get(key: string) {
+  const cacheItem = values.get(key);
+  if (cacheItem) {
+    if (cacheItem.expireAt === -1) {
+      return cacheItem.value;
     }
 
-    const cacheItem = {
-      value,
-      expireAt,
-    };
-    values.set(key, cacheItem);
+    if (cacheItem.expireAt >= new Date().valueOf()) {
+      return cacheItem.value;
+    }
+  }
+
+  return undefined;
+}
+
+export default class MemoryCache implements Cache {
+  async set(key: string, value: string, options?: SetValueOptions) {
+    await set(key, value, options);
+  }
+
+  async setObject(key: string, value: Record<string, any>, options?: SetValueOptions) {
+    await set(key, value, options);
   }
 
   async get(key: string) {
-    const cacheItem = values.get(key);
-    if (cacheItem) {
-      if (cacheItem.expireAt === -1) {
-        return cacheItem.value;
-      }
-
-      if (cacheItem.expireAt >= new Date().valueOf()) {
-        return cacheItem.value;
-      }
-    }
+    return get(key);
+  }
 
-    return undefined;
+  async getObject(key: string) {
+    return get(key);
   }
 
   async del(key: string) {

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

@@ -11,7 +11,10 @@ export * from "./core/server";
 export * from "./core/http-types";
 export * from "./core/actionHandler";
 
+export * from "./utilities/accessControlUtility";
+export * from "./utilities/entityUtility";
 export * from "./utilities/jwtUtility";
+export * from "./utilities/timeUtility";
 
 export * from "./deno-std/http/cookie";
 

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) {

package/src/utilities/entityUtility.ts

@@ -0,0 +1,18 @@
+import { isObject } from "lodash";
+
+export function getEntityRelationTargetId(entity: Record<string, any>, propName: string, targetColumnName?: string) {
+  if (!entity) {
+    throw new Error(`"entity" parameter is required.`);
+  }
+
+  let targetId: number | { id?: number } = entity[propName];
+  if (!targetId && targetColumnName) {
+    targetId = entity[targetColumnName];
+  }
+
+  if (isObject(targetId)) {
+    return targetId.id;
+  } else {
+    return targetId;
+  }
+}