@alanszp/business-days-date-fns 4.0.10

package/src/utils/withNonBusinessDays.test.ts

@@ -0,0 +1,82 @@
+import assert from "assert";
+import { withNonBusinessDays } from "./withNonBusinessDays";
+
+const mockNBD = [new Date("2022-01-19"), new Date("2022-01-20")];
+const mockSerializer = jest.fn();
+
+describe("withNonBusinessDays", () => {
+  it("bootstraping sync should return fns", () => {
+    const {
+      addBusinessDays,
+      subBusinessDays,
+      isBusinessDay,
+      isNonBusinessDay,
+      differenceInBusinessDays,
+    } = withNonBusinessDays([new Date("2022-01-01"), new Date("2022-01-10")]);
+
+    expect(typeof addBusinessDays).toBe("function");
+    expect(typeof subBusinessDays).toBe("function");
+    expect(typeof isBusinessDay).toBe("function");
+    expect(typeof isNonBusinessDay).toBe("function");
+    expect(typeof differenceInBusinessDays).toBe("function");
+  });
+
+  it("bootstraping async should return fns and call serializer", async () => {
+    const mockFetchStrategy = jest.fn();
+    mockFetchStrategy.mockImplementation(() => Promise.resolve(mockNBD));
+
+    const {
+      addBusinessDays,
+      subBusinessDays,
+      isBusinessDay,
+      isNonBusinessDay,
+      differenceInBusinessDays,
+    } = withNonBusinessDays(mockFetchStrategy, {
+      serializeOptions: mockSerializer,
+    });
+
+    expect(typeof addBusinessDays).toBe("function");
+    expect(typeof subBusinessDays).toBe("function");
+    expect(typeof isBusinessDay).toBe("function");
+    expect(typeof isNonBusinessDay).toBe("function");
+    expect(typeof differenceInBusinessDays).toBe("function");
+
+    await addBusinessDays(new Date(), 1, { month: 1 });
+
+    expect(mockSerializer).toHaveBeenCalledWith({ month: 1 });
+    expect(mockFetchStrategy).toHaveBeenCalled();
+  });
+
+  it("bootstraping async addBusinessDays", async () => {
+    const mockFetchStrategy = jest.fn();
+    mockFetchStrategy.mockImplementation(() => Promise.resolve(mockNBD));
+    const { addBusinessDays } = withNonBusinessDays(mockFetchStrategy, {
+      serializeOptions: (obj) => JSON.stringify(obj),
+    });
+
+    const result = await addBusinessDays(new Date("2022-01-18"), 1);
+    expect(result).toEqual(new Date("2022-01-21"));
+  });
+
+  it("bootstraping async throw error", async () => {
+    const mockFetchStrategy = jest.fn();
+    mockFetchStrategy.mockImplementation(() => Promise.reject());
+    try {
+      assert.throws(withNonBusinessDays.bind(mockFetchStrategy), TypeError);
+    } catch {}
+  });
+
+  it("bootstraping sync addBusinessDays", () => {
+    const { addBusinessDays } = withNonBusinessDays(mockNBD);
+
+    const result = addBusinessDays(new Date("2022-01-18"), 1);
+    expect(result).toEqual(new Date("2022-01-21"));
+  });
+
+  it("bootstraping should throw error for bad input", () => {
+    try {
+      assert.throws(withNonBusinessDays.bind(null), TypeError);
+      assert.throws(withNonBusinessDays.bind(null), TypeError);
+    } catch {}
+  });
+});

package/src/utils/withNonBusinessDays.ts

@@ -0,0 +1,87 @@
+import isFunction, { isArray } from "lodash/";
+import { Options as CacheOptions } from "lru-cache";
+import { addBusinessDays } from "./addBusinessDays";
+import { subBusinessDays } from "./subBusinessDays";
+import { differenceInBusinessDays } from "./differenceInBusinessDays";
+import {
+  wrapperDateAndNumberNonBusinessDays,
+  wrapperDateNonBusinessDays,
+} from "./wrapperNonBusinessDays";
+import { isNonBusinessDay } from "./isNonBusinessDay";
+import { isBusinessDay } from "./isBusinessDay";
+import { buildNonBusinessDaysCache } from "../cache";
+
+export type WithNonBusinessDaysOutput<IdentifyObject> = {
+  addBusinessDays: (
+    dirtyDate: Date | number,
+    dirtyAmount: number,
+    identify?: IdentifyObject
+  ) => Promise<Date> | Date;
+  subBusinessDays: (
+    dirtyDate: Date | number,
+    dirtyAmount: number,
+    identify?: IdentifyObject
+  ) => Promise<Date> | Date;
+  differenceInBusinessDays: (
+    dirtyDate: Date | number,
+    dirtyAmount: number,
+    identify: IdentifyObject
+  ) => Promise<number> | number;
+  isNonBusinessDay: (
+    date: Date,
+    identify: IdentifyObject
+  ) => Promise<boolean> | boolean;
+  isBusinessDay: (
+    date: Date,
+    identify: IdentifyObject
+  ) => Promise<boolean> | boolean;
+};
+
+export function withNonBusinessDays<Options>(
+  fetchStrategy: ((opts?: Options) => Promise<Date[]>) | Date[],
+  cacheOpts?: CacheOptions<string, Date[]> & {
+    serializeOptions?: (opts?: Options) => string;
+  }
+): WithNonBusinessDaysOutput<Options> {
+  if (!isFunction(fetchStrategy) && !isArray(fetchStrategy)) {
+    throw new Error(
+      "You must send a function for fetchStrategy or a list of dates"
+    );
+  }
+
+  const cache = buildNonBusinessDaysCache(cacheOpts);
+
+  return {
+    addBusinessDays: wrapperDateAndNumberNonBusinessDays(
+      cache,
+      fetchStrategy,
+      addBusinessDays,
+      cacheOpts?.serializeOptions
+    ),
+    differenceInBusinessDays: wrapperDateAndNumberNonBusinessDays(
+      cache,
+
+      fetchStrategy,
+      differenceInBusinessDays,
+      cacheOpts?.serializeOptions
+    ),
+    subBusinessDays: wrapperDateAndNumberNonBusinessDays(
+      cache,
+      fetchStrategy,
+      subBusinessDays,
+      cacheOpts?.serializeOptions
+    ),
+    isNonBusinessDay: wrapperDateNonBusinessDays(
+      cache,
+      fetchStrategy,
+      isNonBusinessDay,
+      cacheOpts?.serializeOptions
+    ),
+    isBusinessDay: wrapperDateNonBusinessDays(
+      cache,
+      fetchStrategy,
+      isBusinessDay,
+      cacheOpts?.serializeOptions
+    ),
+  };
+}

package/src/utils/wrapperNonBusinessDays.ts

@@ -0,0 +1,78 @@
+import { InternalServerError } from "@alanszp/errors";
+import isArray from "lodash/isArray";
+import LRUCache from "lru-cache";
+
+export function wrapperDateAndNumberNonBusinessDays<IdentifyObject, R>(
+  cacheNBD: LRUCache<string, Date[]>,
+  fetchStrategy: ((opts?: IdentifyObject) => Promise<Date[]>) | Date[],
+  fn: (
+    nonBusinessDays: Date[],
+    dirtyDate: Date | number,
+    dirtyAmount: number
+  ) => R,
+  serializeOptions?: (opts?: IdentifyObject) => string
+) {
+  if (isArray(fetchStrategy)) {
+    return (dirtyDate: Date | number, dirtyAmount: number) =>
+      fn(fetchStrategy, dirtyDate, dirtyAmount);
+  }
+
+  return async (
+    dirtyDate: Date | number,
+    dirtyAmount: number,
+    identify?: IdentifyObject
+  ): Promise<R> => {
+    const cacheIdentify = serializeOptions
+      ? serializeOptions(identify)
+      : JSON.stringify(identify);
+    const cache = cacheNBD.get(cacheIdentify);
+
+    let nonBusinessDays: Date[] = [];
+
+    if (!cache) {
+      try {
+        nonBusinessDays = await fetchStrategy(identify);
+        cacheNBD.set(cacheIdentify, nonBusinessDays);
+      } catch (error: unknown) {
+        throw new InternalServerError(error);
+      }
+    } else {
+      nonBusinessDays = cache;
+    }
+
+    return fn(nonBusinessDays, dirtyDate, dirtyAmount);
+  };
+}
+
+export function wrapperDateNonBusinessDays<IdentifyObject, R>(
+  cacheNBD: LRUCache<string, Date[]>,
+  fetchStrategy: ((opts?: IdentifyObject) => Promise<Date[]>) | Date[],
+  fn: (nonBusinessDays: Date[], date: Date) => R,
+  serializeOptions?: (opts?: IdentifyObject) => string
+) {
+  if (isArray(fetchStrategy)) {
+    return (date: Date) => fn(fetchStrategy, date);
+  }
+
+  return async (date: Date, identify?: IdentifyObject): Promise<R> => {
+    const cacheIdentify = serializeOptions
+      ? serializeOptions(identify)
+      : JSON.stringify(identify);
+    const cache = cacheNBD.get(cacheIdentify);
+
+    let nonBusinessDays: Date[] = [];
+
+    if (!cache) {
+      try {
+        nonBusinessDays = await fetchStrategy(identify);
+        cacheNBD.set(cacheIdentify, nonBusinessDays);
+      } catch (error: unknown) {
+        throw new InternalServerError(error);
+      }
+    } else {
+      nonBusinessDays = cache;
+    }
+
+    return fn(nonBusinessDays, date);
+  };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "module": "commonjs",
+    "target": "es6",
+    "types": ["jest", "node"],
+    "esModuleInterop": true,
+    "sourceMap": true,
+
+    "alwaysStrict": true,
+    "strictNullChecks": true
+  },
+  "exclude": ["node_modules"]
+}