@ruiapp/rapid-core 0.5.11 → 0.5.13

package/src/facilities/cache/CacheFacilityTypes.ts

@@ -1,27 +1,29 @@
-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>;
-}
-
-export interface SetValueOptions {
-  /**
-   * Time-to-live, in milliseconds
-   */
-  ttl?: number;
-}
-
-export interface CreateCacheFacilityOptions {
-  providerName: string;
-}
+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: 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 {
+  /**
+   * Time-to-live, in milliseconds
+   */
+  ttl?: number;
+}
+
+export interface CreateCacheFacilityOptions {
+  providerName: string;
+}

package/src/facilities/cache/CacheFactory.ts

@@ -1,31 +1,31 @@
-import { FacilityFactory } from "~/core/facility";
-import { IRpdServer } from "~/core/server";
-import { Cache, CacheProvider, CacheFactoryConfig, CreateCacheFacilityOptions } from "./CacheFacilityTypes";
-import MemoryCacheProvider from "./MemoryCacheProvider";
-
-export default class CacheFactory implements FacilityFactory<Cache, CreateCacheFacilityOptions> {
-  readonly name: string;
-  #providers: Map<string, CacheProvider>;
-
-  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?: 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);
-  }
-}
+import { FacilityFactory } from "~/core/facility";
+import { IRpdServer } from "~/core/server";
+import { Cache, CacheProvider, CacheFactoryConfig, CreateCacheFacilityOptions } from "./CacheFacilityTypes";
+import MemoryCacheProvider from "./MemoryCacheProvider";
+
+export default class CacheFactory implements FacilityFactory<Cache, CreateCacheFacilityOptions> {
+  readonly name: string;
+  #providers: Map<string, CacheProvider>;
+
+  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?: 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,42 +1,58 @@
-import { Cache, SetValueOptions } from "./CacheFacilityTypes";
-
-export type MemoryCacheItem<TValue = any> = {
-  value: TValue;
-  expireAt: number;
-};
-
-const values: Map<string, MemoryCacheItem> = new Map();
-
-export default class MemoryCache implements Cache {
-  async 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 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 undefined;
-  }
-
-  async del(key: string) {
-    values.delete(key);
-  }
-}
+import { Cache, SetValueOptions } from "./CacheFacilityTypes";
+
+export type MemoryCacheItem<TValue = any> = {
+  value: TValue;
+  expireAt: number;
+};
+
+const values: Map<string, MemoryCacheItem> = new Map();
+
+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;
+    }
+
+    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) {
+    return get(key);
+  }
+
+  async getObject(key: string) {
+    return get(key);
+  }
+
+  async del(key: string) {
+    values.delete(key);
+  }
+}

package/src/facilities/cache/MemoryCacheProvider.ts

@@ -1,15 +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();
-  }
-}
+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/facilities/log/LogFacility.ts

@@ -1,35 +1,35 @@
-import winston from "winston";
-
-export interface Logger {
-  log: winston.LogMethod;
-  /**
-   * The service/app is going to stop or become unusable now. An operator should definitely look into this immediately.
-   */
-  emerg: winston.LeveledLogMethod;
-  /**
-   * Fatal for a particular service, but the app continues servicing other requests. An operator should look at this immediately.
-   */
-  crit: winston.LeveledLogMethod;
-  /**
-   * Fatal for a particular request, but the service/app continues servicing other requests. An operator should look at this soon(ish).
-   */
-  error: winston.LeveledLogMethod;
-  /**
-   * A note on something that should probably be looked at by an operator eventually.
-   */
-  warn: winston.LeveledLogMethod;
-  /**
-   * Detail on regular operation.
-   */
-  info: winston.LeveledLogMethod;
-  /**
-   * Anything else, i.e. too verbose to be included in "info" level.
-   */
-  debug: winston.LeveledLogMethod;
-  /**
-   * Logging from external libraries used by your app or very detailed application logging.
-   */
-  verbose: winston.LeveledLogMethod;
-
-  child(options: Object): Logger;
-}
+import winston from "winston";
+
+export interface Logger {
+  log: winston.LogMethod;
+  /**
+   * The service/app is going to stop or become unusable now. An operator should definitely look into this immediately.
+   */
+  emerg: winston.LeveledLogMethod;
+  /**
+   * Fatal for a particular service, but the app continues servicing other requests. An operator should look at this immediately.
+   */
+  crit: winston.LeveledLogMethod;
+  /**
+   * Fatal for a particular request, but the service/app continues servicing other requests. An operator should look at this soon(ish).
+   */
+  error: winston.LeveledLogMethod;
+  /**
+   * A note on something that should probably be looked at by an operator eventually.
+   */
+  warn: winston.LeveledLogMethod;
+  /**
+   * Detail on regular operation.
+   */
+  info: winston.LeveledLogMethod;
+  /**
+   * Anything else, i.e. too verbose to be included in "info" level.
+   */
+  debug: winston.LeveledLogMethod;
+  /**
+   * Logging from external libraries used by your app or very detailed application logging.
+   */
+  verbose: winston.LeveledLogMethod;
+
+  child(options: Object): Logger;
+}

package/src/helpers/entityHelpers.ts

@@ -1,76 +1,76 @@
-import { isNumber, isObject } from "lodash";
-import { IRpdServer } from "~/core/server";
-import { getEntityPropertyByCode, isOneRelationProperty } from "~/helpers/metaHelper";
-import { RpdDataModel } from "~/types";
-
-export function getEntityPartChanges(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null {
-  if (!before) {
-    throw new Error("Argument 'before' can not be null.");
-  }
-
-  if (!after) {
-    throw new Error("Argument 'after' can not be null.");
-  }
-
-  let changed = false;
-  let changes = {};
-  for (const key in after) {
-    const property = getEntityPropertyByCode(server, model, key);
-    if (property && isOneRelationProperty(property)) {
-      const afterValue: number | { id: number } | null = after[key];
-      const beforeValue: number | { id: number } | null = before[key] || before[property.targetIdColumnName];
-      if (afterValue) {
-        if (isNumber(afterValue)) {
-          if (beforeValue) {
-            if (isNumber(beforeValue)) {
-              if (afterValue != beforeValue) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            } else {
-              if (afterValue != beforeValue.id) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            }
-          } else {
-            changed = true;
-            changes[key] = afterValue;
-          }
-        } else {
-          if (beforeValue) {
-            if (isNumber(beforeValue)) {
-              if (afterValue.id != beforeValue) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            } else {
-              if (afterValue.id != beforeValue.id) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            }
-          } else {
-            changed = true;
-            changes[key] = afterValue;
-          }
-        }
-      } else {
-        if (beforeValue) {
-          changed = true;
-          changes[key] = null;
-        }
-      }
-    } else {
-      if (after[key] != before[key]) {
-        changed = true;
-        changes[key] = after[key];
-      }
-    }
-  }
-
-  if (changed) {
-    return changes;
-  }
-  return null;
-}
+import { isNumber, isObject } from "lodash";
+import { IRpdServer } from "~/core/server";
+import { getEntityPropertyByCode, isOneRelationProperty } from "~/helpers/metaHelper";
+import { RpdDataModel } from "~/types";
+
+export function getEntityPartChanges(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null {
+  if (!before) {
+    throw new Error("Argument 'before' can not be null.");
+  }
+
+  if (!after) {
+    throw new Error("Argument 'after' can not be null.");
+  }
+
+  let changed = false;
+  let changes = {};
+  for (const key in after) {
+    const property = getEntityPropertyByCode(server, model, key);
+    if (property && isOneRelationProperty(property)) {
+      const afterValue: number | { id: number } | null = after[key];
+      const beforeValue: number | { id: number } | null = before[key] || before[property.targetIdColumnName];
+      if (afterValue) {
+        if (isNumber(afterValue)) {
+          if (beforeValue) {
+            if (isNumber(beforeValue)) {
+              if (afterValue != beforeValue) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            } else {
+              if (afterValue != beforeValue.id) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            }
+          } else {
+            changed = true;
+            changes[key] = afterValue;
+          }
+        } else {
+          if (beforeValue) {
+            if (isNumber(beforeValue)) {
+              if (afterValue.id != beforeValue) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            } else {
+              if (afterValue.id != beforeValue.id) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            }
+          } else {
+            changed = true;
+            changes[key] = afterValue;
+          }
+        }
+      } else {
+        if (beforeValue) {
+          changed = true;
+          changes[key] = null;
+        }
+      }
+    } else {
+      if (after[key] != before[key]) {
+        changed = true;
+        changes[key] = after[key];
+      }
+    }
+  }
+
+  if (changed) {
+    return changes;
+  }
+  return null;
+}