@openmrs/esm-utils 3.1.10-pre.97 → 3.1.11-pre.595

package/src/omrs-dates.test.ts

@@ -1,4 +1,8 @@
-import { toOmrsIsoString } from "./omrs-dates";
+import {
+  toOmrsIsoString,
+  toDateObjectStrict,
+  isOmrsDateStrict,
+} from "./omrs-dates";
 import dayjs from "dayjs";
 
 describe("Openmrs Dates", () => {
@@ -9,4 +13,32 @@ describe("Openmrs Dates", () => {
     ).toDate();
     expect(toOmrsIsoString(date, true)).toEqual("2018-03-18T21:05:03.999+0000");
   });
+
+  it("checks if a string is openmrs date", () => {
+    expect(isOmrsDateStrict("2018-03-19T00:00:00.000+0300")).toEqual(true);
+    expect(isOmrsDateStrict(" 2018-03-19T00:00:00.000+0300 ")).toEqual(true);
+    // the exclusion test cases are important for strictness
+    expect(isOmrsDateStrict("2018-03-19 00:00:00.000+0300")).toEqual(false);
+    expect(isOmrsDateStrict("2018-03-19T00:00:00.000+03:00")).toEqual(false);
+    expect(isOmrsDateStrict("2018-03-19T00:00:00.000 0300")).toEqual(false);
+    expect(isOmrsDateStrict("2018-03-19T00:00:00 000+0300")).toEqual(false);
+    expect(isOmrsDateStrict("2018-03-1")).toEqual(false);
+    expect(isOmrsDateStrict("")).toEqual(false);
+    expect(isOmrsDateStrict(null as any)).toEqual(false);
+    expect(isOmrsDateStrict(undefined as any)).toEqual(false);
+  });
+  it("converts omrs date string version to js Date object", () => {
+    expect(
+      toDateObjectStrict("2018-03-19T00:00:00.000+0300")?.toUTCString()
+    ).toEqual("Sun, 18 Mar 2018 21:00:00 GMT");
+    expect(toDateObjectStrict("2018-03-19")).toEqual(null);
+  });
+
+  it("converts js Date object to omrs date string version", () => {
+    var date = dayjs(
+      "2018-03-19T00:05:03.999+0300",
+      "YYYY-MM-DDTHH:mm:ss.SSSZZ"
+    ).toDate();
+    expect(toOmrsIsoString(date, true)).toEqual("2018-03-18T21:05:03.999+0000");
+  });
 });

package/src/retry.ts

@@ -0,0 +1,83 @@
+/**
+ * Options for configuring the behavior of the {@link retry} function.
+ */
+export interface RetryOptions {
+  /**
+   * Determines whether the retry function should retry executing the function after it failed
+   * with an error on the current attempt.
+   * @param attempt The current (zero-based) retry attempt. `0` indicates the initial attempt.
+   */
+  shouldRetry?(attempt: number);
+  /**
+   * Calculates the next delay (in milliseconds) before a retry attempt.
+   * Returning a value for the inital attempt (`0`) delays the initial function invocation.
+   * @param attempt The current (zero-based) retry attempt. `0` indicates the initial attempt.
+   */
+  getDelay?(attempt: number): number;
+  /**
+   * Called when invoking the function resulted in an error.
+   * Allows running side-effects on errors, e.g. logging.
+   * @param e The error thrown by the function.
+   * @param attempt The current (zero-based) retry attempt. `0` indicates the initial attempt.
+   */
+  onError?(e: any, attempt: number): void;
+}
+
+/**
+ * Executes the specified function and retries executing on failure with a custom backoff strategy
+ * defined by the options.
+ *
+ * If not configured otherwise, this function uses the following default options:
+ * * Retries 5 times beyond the initial attempt.
+ * * Uses an exponential backoff starting with an initial delay of 1000ms.
+ * @param fn The function to be executed and retried on failure.
+ * @param options Additional options which configure the retry behavior.
+ * @returns The result of successfully executing `fn`.
+ * @throws Rethrows the final error of running `fn` when the function stops retrying.
+ */
+export async function retry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {}
+) {
+  let { shouldRetry, getDelay, onError } = options;
+  shouldRetry = shouldRetry ?? ((attempt) => limitAttempts(attempt, 5));
+  getDelay = getDelay ?? ((attempt) => getExponentialDelay(attempt, 1000));
+
+  let attempt = 0;
+  let lastError: any = undefined;
+
+  do {
+    try {
+      await delay(getDelay(attempt));
+      return await fn();
+    } catch (e) {
+      onError?.(e, attempt);
+      lastError = e;
+    }
+  } while (shouldRetry(attempt++));
+
+  // If we reach this fn errored and shouldn't retry anymore. Simply rethrow the final error as
+  // a means of ending the retry process without a result.
+  throw lastError;
+}
+
+function limitAttempts(attempt: number, maxAttempts: number) {
+  return attempt <= maxAttempts;
+}
+
+function getExponentialDelay(
+  attempt: number,
+  startingDelay: number,
+  initialDelay = false
+) {
+  const exponent = initialDelay ? attempt + 1 : attempt;
+  return startingDelay * Math.pow(2, exponent);
+}
+
+async function delay(ms: number) {
+  if (ms <= 0) {
+    return;
+  }
+
+  return new Promise<void>((res) => setTimeout(res, ms));
+}

package/src/translate.ts

@@ -0,0 +1,13 @@
+import _i18n from "i18next";
+
+export function translateFrom(
+  moduleName: string,
+  key: string,
+  fallback?: string
+) {
+  const i18n: typeof _i18n = (_i18n as any).default || _i18n;
+  return i18n.t(key, {
+    ns: moduleName,
+    defaultValue: fallback,
+  });
+}

package/src/version.test.ts

@@ -0,0 +1,53 @@
+import { isVersionSatisfied } from "./version";
+
+describe("Version utilities", () => {
+  it("Is satisfied if exactly equals", () => {
+    const result = isVersionSatisfied("1.2.3", "1.2.3");
+    expect(result).toBe(true);
+  });
+
+  it("Is satisfied if caret and minor change", () => {
+    const result = isVersionSatisfied("^1.2.3", "1.3.0");
+    expect(result).toBe(true);
+  });
+
+  it("Is not satisfied if exact and minor change", () => {
+    const result = isVersionSatisfied("1.2.3", "1.3.0");
+    expect(result).toBe(false);
+  });
+
+  it("Is not satisfied if caret and major change", () => {
+    const result = isVersionSatisfied("^1.2.3", "2.0.0");
+    expect(result).toBe(false);
+  });
+
+  it("Is satisfied if caret and minor change with prerelease", () => {
+    const result = isVersionSatisfied("^1.2.3", "1.3.0-alpha.1");
+    expect(result).toBe(true);
+  });
+
+  it("Is not satisfied if version equals same prerelease", () => {
+    const result = isVersionSatisfied("^3.1.10", "3.1.10-pre.284");
+    expect(result).toBe(false);
+  });
+
+  it("Is satisfied if version equals higher with build number", () => {
+    const result = isVersionSatisfied("^2.24.0", "2.30.0.7e24fb");
+    expect(result).toBe(true);
+  });
+
+  it("Is satisfied if version equals higher with build number and pre", () => {
+    const result = isVersionSatisfied("^2.24.0", "2.30.0.7e24fb-pre.3");
+    expect(result).toBe(true);
+  });
+
+  it("Is not satisfied if version equals same with build number and pre", () => {
+    const result = isVersionSatisfied("^2.24.0", "2.24.0.7e24fb-pre.3");
+    expect(result).toBe(false);
+  });
+
+  it("Is satisfied if version equals same with only build number", () => {
+    const result = isVersionSatisfied("^2.24.0", "2.24.0.7e24fb");
+    expect(result).toBe(true);
+  });
+});

package/src/version.ts

@@ -0,0 +1,30 @@
+import * as semver from "semver";
+
+function normalizeOnlyVersion(version: string) {
+  const [major, minor, patch] = version.split(".");
+  return `${major}.${minor}.${patch}`;
+}
+
+function normalizeFullVersion(version: string) {
+  const idx = version.indexOf("-");
+  const prerelease = idx >= 0;
+
+  if (prerelease) {
+    const ver = normalizeOnlyVersion(version.substr(0, idx));
+    const pre = version.substr(idx + 1);
+    return `${ver}-${pre}`;
+  }
+
+  return normalizeOnlyVersion(version);
+}
+
+export function isVersionSatisfied(
+  requiredVersion: string,
+  installedVersion: string
+) {
+  const version = normalizeFullVersion(installedVersion);
+
+  return semver.satisfies(version, requiredVersion, {
+    includePrerelease: true,
+  });
+}

package/webpack.config.js

@@ -1,4 +1,5 @@
 const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
+const SystemJSPublicPathWebpackPlugin = require("systemjs-webpack-interop/SystemJSPublicPathWebpackPlugin");
 const { resolve } = require("path");
 const { CleanWebpackPlugin } = require("clean-webpack-plugin");
 const { BundleAnalyzerPlugin } = require("webpack-bundle-analyzer");
@@ -6,23 +7,15 @@ const { BundleAnalyzerPlugin } = require("webpack-bundle-analyzer");
 const { peerDependencies } = require("./package.json");
 
 module.exports = (env) => ({
-  entry: [
-    resolve(__dirname, "src/set-public-path.ts"),
-    resolve(__dirname, "src/index.ts"),
-  ],
+  entry: [resolve(__dirname, "src/index.ts")],
   output: {
     filename: "openmrs-esm-utils.js",
     path: resolve(__dirname, "dist"),
     libraryTarget: "system",
   },
-  devtool: "sourcemap",
+  devtool: "source-map",
   module: {
     rules: [
-      {
-        parser: {
-          system: false,
-        },
-      },
       {
         test: /\.m?(js|ts|tsx)$/,
         exclude: /(node_modules|bower_components)/,
@@ -30,11 +23,12 @@ module.exports = (env) => ({
       },
     ],
   },
-  externals: Object.keys(peerDependencies),
+  externals: Object.keys(peerDependencies || {}),
   resolve: {
     extensions: [".ts", ".js", ".tsx", ".jsx"],
   },
   plugins: [
+    new SystemJSPublicPathWebpackPlugin(),
     new CleanWebpackPlugin(),
     new ForkTsCheckerWebpackPlugin(),
     new BundleAnalyzerPlugin({

package/src/set-public-path.ts

@@ -1,3 +0,0 @@
-import { setPublicPath } from "systemjs-webpack-interop";
-
-setPublicPath("@openmrs/esm-utils");