feathers-utils 5.0.2 → 5.2.0

package/src/utils/getItemsIsArray.ts

@@ -41,3 +41,282 @@ export const getItemsIsArray = <T = any, H extends HookContext = HookContext>(
     isArray,
   };
 };
+
+if (import.meta.vitest) {
+  const { describe, it, assert } = import.meta.vitest;
+
+  const assertBefore = (context, items, isArray) => {
+    const arrays: (GetItemsIsArrayFrom | undefined)[] = [
+      undefined,
+      "data",
+      "automatic",
+    ];
+
+    for (const from of arrays) {
+      const { items: items2, isArray: isArray2 } = getItemsIsArray(context, {
+        from,
+      });
+      assert.deepStrictEqual(items2, items, `from: ${from}`);
+      assert.deepStrictEqual(isArray2, isArray, `from: ${from}`);
+    }
+  };
+
+  const assertAfter = (context, items, isArray) => {
+    const arrays: (GetItemsIsArrayFrom | undefined)[] = [
+      undefined,
+      "result",
+      "automatic",
+    ];
+
+    for (const from of arrays) {
+      const { items: items2, isArray: isArray2 } = getItemsIsArray(context, {
+        from,
+      });
+      assert.deepStrictEqual(items2, items, `from: ${from}`);
+      assert.deepStrictEqual(isArray2, isArray, `from: ${from}`);
+    }
+  };
+
+  describe("before", function () {
+    it("find:before", async function () {
+      const context = {
+        type: "before",
+        method: "find",
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+
+    it("get:before", async function () {
+      const context = {
+        type: "before",
+        method: "get",
+        id: 1,
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+
+    it("create:before single", async function () {
+      const context = {
+        type: "before",
+        method: "create",
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("create:before multi", async function () {
+      const context = {
+        type: "before",
+        method: "create",
+        data: [{ test: true }, { test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }, { test: true }], true);
+    });
+
+    it("update:before single", async function () {
+      const context = {
+        type: "before",
+        method: "update",
+        id: 1,
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("patch:before single", async function () {
+      const context = {
+        type: "before",
+        method: "patch",
+        id: 1,
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("patch:before multi", async function () {
+      const context = {
+        type: "before",
+        method: "patch",
+        id: null,
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("remove:before single", async function () {
+      const context = {
+        type: "before",
+        method: "remove",
+        id: 1,
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+
+    it("remove:before multi", async function () {
+      const context = {
+        type: "before",
+        method: "remove",
+        id: null,
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+  });
+
+  describe("after", function () {
+    it("find:after paginate:true", function () {
+      const context = {
+        type: "after",
+        method: "find",
+        result: {
+          total: 1,
+          skip: 0,
+          limit: 10,
+          data: [{ test: true }],
+        },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], true);
+    });
+
+    it("find:after paginate:false", function () {
+      const context = {
+        type: "after",
+        method: "find",
+        result: [{ test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], true);
+    });
+
+    it("get:after", function () {
+      const context = {
+        type: "after",
+        method: "get",
+        id: 1,
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("update:after", function () {
+      const context = {
+        type: "after",
+        method: "update",
+        id: 1,
+        data: { test: "yes" },
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("patch:after single", function () {
+      const context = {
+        type: "after",
+        method: "patch",
+        id: 1,
+        data: { test: "yes" },
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("patch:after multi", function () {
+      const context = {
+        type: "after",
+        method: "patch",
+        id: null,
+        data: { test: "yes" },
+        result: [{ test: true }, { test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }, { test: true }], true);
+    });
+
+    it("remove:after single", function () {
+      const context = {
+        type: "after",
+        method: "remove",
+        id: 1,
+        data: { test: "yes" },
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("remove:after multi", function () {
+      const context = {
+        type: "after",
+        method: "remove",
+        id: null,
+        data: { test: "yes" },
+        result: [{ test: true }, { test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }, { test: true }], true);
+    });
+  });
+}

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);
+  });
+}