feathers-utils 5.1.0 → 6.0.0

package/src/utils/getPaginate.ts

@@ -1,6 +1,6 @@
 import type { PaginationOptions } from "@feathersjs/adapter-commons";
 import type { HookContext } from "@feathersjs/feathers";
-import { hasOwnProperty } from "./internal.utils";
+import { hasOwnProperty } from "./_utils.internal";
 
 /**
  * util to get paginate options from context
@@ -27,3 +27,76 @@ export const getPaginate = <H extends HookContext = HookContext>(
 
   return options.paginate || undefined;
 };
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+
+  it("returns service.options.paginate", function () {
+    const serviceOptions = {
+      paginate: {
+        default: 10,
+        max: 50,
+      },
+    };
+
+    const paginate = getPaginate({
+      params: {},
+      service: {
+        options: serviceOptions,
+      },
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, { default: 10, max: 50 });
+  });
+
+  it("returns undefined for params.paginate: false", function () {
+    const serviceOptions = {
+      paginate: {
+        default: 10,
+        max: 50,
+      },
+    };
+
+    const paginate = getPaginate({
+      params: { paginate: false },
+      service: {
+        options: serviceOptions,
+      },
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, undefined);
+  });
+
+  it("returns context.adapter.paginate over service.options.paginate", function () {
+    const serviceOptions = {
+      paginate: {
+        default: 10,
+        max: 50,
+      },
+    };
+
+    const paginate = getPaginate({
+      params: { adapter: { paginate: { default: 20, max: 100 } } },
+      service: {
+        options: serviceOptions,
+      },
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, { default: 20, max: 100 });
+  });
+
+  it("returns undefined for no paginate", function () {
+    const serviceOptions = {
+      paginate: false,
+    };
+
+    const paginate = getPaginate({
+      params: {},
+      service: {
+        options: serviceOptions,
+      },
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, undefined);
+  });
+}

package/src/utils/index.ts

@@ -13,3 +13,5 @@ export * from "./shouldSkip";
 export * from "./toJSON";
 export * from "./validateQueryProperty";
 export * from "./optimizeBatchPatch";
+export * from "./flattenQuery";
+export * from "./deflattenQuery";

package/src/utils/isMulti.ts

@@ -25,3 +25,54 @@ export const isMulti = <H extends HookContext = HookContext>(
   }
   return false;
 };
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+
+  it("returns true", function () {
+    const makeContext = (type: string, method: string) => {
+      const context = {
+        method,
+        type,
+      } as HookContext;
+      if (method === "create") {
+        type === "before" ? (context.data = []) : (context.result = []);
+      }
+      return context;
+    };
+    ["before", "after"].forEach((type) => {
+      ["find", "create", "patch", "remove"].forEach((method) => {
+        const context = makeContext(type, method);
+        assert.strictEqual(
+          isMulti(context),
+          true,
+          `'${type}:${method}': returns true`,
+        );
+      });
+    });
+  });
+
+  it("returns false", function () {
+    const makeContext = (type: string, method: string) => {
+      const context = {
+        method,
+        type,
+        id: 0,
+      } as HookContext;
+      if (method === "create") {
+        type === "before" ? (context.data = {}) : (context.result = {});
+      }
+      return context;
+    };
+    ["before", "after"].forEach((type) => {
+      ["get", "create", "update", "patch", "remove"].forEach((method) => {
+        const context = makeContext(type, method);
+        assert.strictEqual(
+          isMulti(context),
+          false,
+          `'${type}:${method}': returns false`,
+        );
+      });
+    });
+  });
+}

package/src/utils/isPaginated.ts

@@ -15,3 +15,75 @@ export const isPaginated = <H extends HookContext = HookContext>(
 
   return !!paginate;
 };
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+
+  it("returns true for service.options.paginate", function () {
+    const serviceOptions = {
+      paginate: {
+        default: 10,
+        max: 50,
+      },
+    };
+
+    const paginate = isPaginated({
+      params: {},
+      service: {
+        options: serviceOptions,
+      },
+      method: "find",
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, true);
+  });
+
+  it("returns false for params.paginate: false", function () {
+    const serviceOptions = {
+      paginate: {
+        default: 10,
+        max: 50,
+      },
+    };
+
+    const paginate = isPaginated({
+      params: { paginate: false },
+      service: {
+        options: serviceOptions,
+      },
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, false);
+  });
+
+  it("returns true for context.adapter.paginate", function () {
+    const serviceOptions = {
+      paginate: false,
+    };
+
+    const paginate = isPaginated({
+      params: { adapter: { paginate: { default: 20, max: 100 } } },
+      service: {
+        options: serviceOptions,
+      },
+      method: "find",
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, true);
+  });
+
+  it("returns false for no paginate", function () {
+    const serviceOptions = {
+      paginate: false,
+    };
+
+    const paginate = isPaginated({
+      params: {},
+      service: {
+        options: serviceOptions,
+      },
+    } as HookContext);
+
+    assert.deepStrictEqual(paginate, false);
+  });
+}

package/src/utils/markHookForSkip.ts

@@ -27,3 +27,414 @@ export function markHookForSkip<H extends HookContext = HookContext>(
   context!.params = params;
   return context;
 }
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+  const { feathers } = await import("@feathersjs/feathers");
+  const { MemoryService } = await import("@feathersjs/memory");
+  const { hasOwnProperty } = await import("./_utils.internal");
+  const { shouldSkip } = await import("./shouldSkip");
+
+  it("returns hook object", function () {
+    const context = markHookForSkip("test", "all");
+    assert.ok(context, "returned context");
+    assert.ok(context.params.skipHooks, "has skipHooks");
+  });
+
+  it("returns hook object for undefined context", function () {
+    const context = markHookForSkip("test", "all");
+    assert.ok(context, "returned context");
+    assert.ok(context.params.skipHooks, "has skipHooks");
+  });
+
+  it("skips explicitly before hook", async function () {
+    const app = feathers();
+    app.use("service", new MemoryService());
+    const service = app.service("service");
+    const ranInto = {};
+    service.hooks({
+      before: {
+        all: [
+          (context) => {
+            markHookForSkip("test", "before", context);
+          },
+        ],
+        find: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["find"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        get: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["get"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        create: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["create"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        update: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["update"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        patch: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["patch"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        remove: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["remove"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+      },
+    });
+    const methods = {
+      find: [],
+      get: [1],
+      create: [{}],
+      update: [1, {}],
+      patch: [1, {}],
+      remove: [1],
+    };
+    const promises = Object.keys(methods).map(async (method) => {
+      await service[method](...methods[method]);
+      assert.ok(
+        !hasOwnProperty(ranInto, method),
+        `'${method}': did not run into hook`,
+      );
+      return true;
+    });
+
+    const results = await Promise.all(promises);
+    assert.ok(
+      results.every((x) => x === true),
+      "all ok",
+    );
+  });
+
+  it("skips explicitly after hook", async function () {
+    const app = feathers();
+    app.use("service", new MemoryService());
+    const service = app.service("service");
+    const ranInto = {};
+    service.hooks({
+      before: {
+        all: [
+          (context) => {
+            markHookForSkip("test", "after", context);
+          },
+          (context) => {
+            context.result = null;
+            return context;
+          },
+        ],
+      },
+      after: {
+        find: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["find"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        get: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["get"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        create: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["create"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        update: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["update"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        patch: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["patch"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        remove: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranInto["remove"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+      },
+    });
+    const methods = {
+      find: [],
+      get: [1],
+      create: [{}],
+      update: [1, {}],
+      patch: [1, {}],
+      remove: [1],
+    };
+    const promises = Object.keys(methods).map(async (method) => {
+      await service[method](...methods[method]);
+      assert.ok(
+        !hasOwnProperty(ranInto, method),
+        `'${method}': did not run into hook`,
+      );
+      return true;
+    });
+
+    const results = await Promise.all(promises);
+    assert.ok(
+      results.every((x) => x === true),
+      "all ok",
+    );
+  });
+
+  it("skips all hooks", async function () {
+    const app = feathers();
+    app.use("service", new MemoryService());
+    const service = app.service("service");
+    const ranIntoBefore = {};
+    const ranIntoAfter = {};
+    service.hooks({
+      before: {
+        all: [
+          (context) => {
+            markHookForSkip("test", "all", context);
+          },
+        ],
+        find: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoBefore["find"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        get: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoBefore["get"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        create: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoBefore["create"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        update: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoBefore["update"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        patch: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoBefore["patch"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        remove: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoBefore["remove"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+      },
+      after: {
+        find: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoAfter["find"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        get: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoAfter["get"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        create: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoAfter["create"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        update: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoAfter["update"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        patch: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoAfter["patch"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+        remove: [
+          (context) => {
+            if (shouldSkip("test", context)) {
+              return context;
+            }
+            ranIntoAfter["remove"] = true;
+          },
+          (context) => {
+            context.result = null;
+          },
+        ],
+      },
+    });
+    const methods = {
+      find: [],
+      get: [1],
+      create: [{}],
+      update: [1, {}],
+      patch: [1, {}],
+      remove: [1],
+    };
+    const promises = Object.keys(methods).map(async (method) => {
+      await service[method](...methods[method]);
+      assert.ok(
+        !hasOwnProperty(ranIntoBefore, method),
+        `'${method}': did not run into before hook`,
+      );
+      assert.ok(
+        !hasOwnProperty(ranIntoAfter, method),
+        `'${method}': did not run into after hook`,
+      );
+      return true;
+    });
+
+    const results = await Promise.all(promises);
+    assert.ok(
+      results.every((x) => x === true),
+      "all ok",
+    );
+  });
+}

package/src/utils/mergeQuery/mergeArrays.ts

@@ -48,3 +48,71 @@ export function mergeArrays<T>(
   }
   return undefined;
 }
+
+if (import.meta.vitest) {
+  const { it, expect } = import.meta.vitest;
+
+  describe("target", function () {
+    it("returns target", function () {
+      const arr = mergeArrays([1], [2], "target");
+
+      expect(arr).toStrictEqual([1]);
+    });
+
+    it("returns target even if undefined", function () {
+      const arr = mergeArrays(undefined, [1], "target");
+
+      expect(arr).toBeUndefined();
+    });
+  });
+
+  describe("source", function () {
+    it("returns source", function () {
+      const arr = mergeArrays([1], [2], "source");
+
+      expect(arr).toStrictEqual([2]);
+    });
+
+    it("returns source even if undefined", function () {
+      const arr = mergeArrays([1], undefined, "source");
+
+      expect(arr).toBeUndefined();
+    });
+  });
+
+  describe("combine", function () {
+    it("returns combined array", function () {
+      const arr = mergeArrays([1, 2], [2, 3], "combine");
+
+      expect(arr).toStrictEqual([1, 2, 3]);
+    });
+
+    it("returns one array if combine", function () {
+      const arr1 = mergeArrays([1, 2], undefined, "combine");
+
+      expect(arr1).toStrictEqual([1, 2]);
+
+      const arr2 = mergeArrays(undefined, [1, 2], "combine");
+
+      expect(arr2).toStrictEqual([1, 2]);
+    });
+  });
+
+  describe("intersect", function () {
+    it("returns intersected array", function () {
+      const arr = mergeArrays([1, 2], [2, 3], "intersect");
+
+      expect(arr).toStrictEqual([2]);
+    });
+
+    it("returns undefined if one is undefined", function () {
+      const arr1 = mergeArrays([1, 2], undefined, "intersect");
+
+      expect(arr1).toBeUndefined();
+
+      const arr2 = mergeArrays(undefined, [1, 2], "intersect");
+
+      expect(arr2).toBeUndefined();
+    });
+  });
+}