relation-matcher 1.1.0 → 1.1.2

package/README.md

@@ -166,6 +166,14 @@ Record<
 
 ## Changelog
 
+### 1.1.2
+
+- Improved error when item is found to be nullable.
+
+### 1.1.1
+
+- Major refactor.
+
 ### 1.1.0
 
 - Added ability to mark join as `isNullable: false`. This allows for manual marking of single joins as `NonNullable`.

package/dist/src/index.d.ts

@@ -1,6 +1,11 @@
-import type { TInputBase } from "./types/generic-bases";
-import type { RelationMapRoot } from "./types/inputs";
-import type { RelationMapperReturnRoot } from "./types/return";
-export declare const relationMatcherRoot: <TInput extends TInputBase, TOutputRoot extends RelationMapRoot<TInput>>(inputs: TInput[], output: TOutputRoot) => Record<string, RelationMapperReturnRoot<TInput, TOutputRoot>>;
-export declare const relationMatcher: <TInput extends TInputBase, TOutputRoot extends RelationMapRoot<TInput>>(inputs: TInput[], output: TOutputRoot) => Record<string, RelationMapperReturnRoot<TInput, TOutputRoot>>;
+import type { MaybeArray, MaybeNull, SRecord } from "./types";
+import type { TInputBase, TInputBaseJoin } from "./types/generic-bases";
+import type { Output, OutputRoot } from "./types/generic-less";
+import type { RelationMapRoot as Root } from "./types/inputs";
+import type { RelationMapperReturnRoot as ReturnRoot } from "./types/return";
+import { type InvertedInput } from "./utils/invertInput";
+export declare const relationMatcherRoot: <TInput extends TInputBase, TOutputRoot extends Root<TInput>>(inputs: TInput[], output: TOutputRoot) => SRecord<ReturnRoot<TInput, TOutputRoot>>;
+export declare const relationMatcher: <TInput extends TInputBase, TOutputRoot extends Root<TInput>>(inputs: TInput[], output: TOutputRoot) => SRecord<ReturnRoot<TInput, TOutputRoot>>;
 export default relationMatcherRoot;
+declare const joiner: (input: InvertedInput, output: Output | OutputRoot, joiningFrom: SRecord<unknown>) => SRecord<MaybeArray<MaybeNull<TInputBaseJoin>>>;
+export { joiner as relationMatcherJoiner };

package/dist/src/index.js

@@ -1,6 +1,8 @@
 import invertInput, {} from "./utils/invertInput";
+import { assertIsNullable } from "./utils/isNullable";
+import { arrayJoinBase, singleJoinBase } from "./utils/joins";
 import { getJoinFinalKey } from "./utils/keys";
-import { matcherFunc } from "./utils/matcher";
+import { createMatcherFunc } from "./utils/matcher";
 export const relationMatcherRoot = (inputs, output) => {
     if (!inputs.length)
         return {};
@@ -8,79 +10,61 @@ export const relationMatcherRoot = (inputs, output) => {
         throw new Error("Input must be an array.");
     }
     const invertedInput = invertInput(inputs);
-    const baseItems = invertedInput[output.base].reduce((final, row) => {
-        if (!row) {
+    const baseItems = invertedInput[output.base].reduce((final, inputRow) => {
+        if (!inputRow) {
             return final;
         }
-        const relations = Object.entries(output).reduce((final, [key, value]) => {
-            if (typeof value === "object") {
-                const finalKey = getJoinFinalKey(key);
-                if (value.joinType === "array") {
-                    const baseObjArr = invertedInput[value.base].filter(matcherFunc(row, value));
-                    final[finalKey] = Object.values(baseObjArr.reduce((final, item) => {
-                        if (!item)
-                            return final;
-                        final[item[value.id]] = {
-                            ...item,
-                            ...relationMatcherJoiner(invertedInput, value, item),
-                        };
-                        return final;
-                    }, {}));
-                }
-                else {
-                    const item = invertedInput[value.base].find(matcherFunc(row, value)) ?? null;
-                    if (item) {
-                        final[finalKey] = {
-                            ...item,
-                            ...relationMatcherJoiner(invertedInput, value, item),
-                        };
-                    }
-                }
-            }
-            return final;
-        }, {});
-        final[row[output.id]] = { ...row, ...relations };
+        const relations = joiner(invertedInput, output, inputRow);
+        const rowId = inputRow[output.id];
+        final[rowId] = {
+            ...inputRow,
+            ...relations,
+        };
         return final;
     }, {});
     return baseItems;
 };
 export const relationMatcher = relationMatcherRoot;
 export default relationMatcherRoot;
-const relationMatcherJoiner = (input, output, joiningFrom) => {
+const joiner = (input, output, joiningFrom) => {
     return Object.entries(output).reduce((final, [key, value]) => {
-        if (typeof value === "object") {
-            const finalKey = getJoinFinalKey(key);
-            const matcherFunc = (item) => item?.[value.joinsTo] === joiningFrom[value.joinsFrom];
-            if (!input[value.base])
-                throw new Error(`Input is missing rows for ${value.base}.`);
-            if (value.joinType === "array") {
-                const baseObjArr = input[value.base].filter(matcherFunc);
+        if (typeof value !== "object")
+            return final;
+        const finalKey = getJoinFinalKey(key);
+        const matcherFunc = createMatcherFunc(joiningFrom, value);
+        const joinType = input[value.base];
+        if (!joinType)
+            throw new Error(`Input is missing rows for ${value.base}.`);
+        switch (value.joinType) {
+            case "array": {
+                const baseObjArr = arrayJoinBase(joinType, matcherFunc);
                 final[finalKey] = Object.values(baseObjArr.reduce((final, item) => {
-                    if (!item)
-                        return final;
                     const propertyKey = item[value.id];
-                    if (final[propertyKey])
-                        return final;
-                    final[propertyKey] = {
+                    final[propertyKey] ??= {
                         ...item,
-                        ...relationMatcherJoiner(input, value, item),
+                        ...joiner(input, value, item),
                     };
                     return final;
                 }, {}));
+                break;
             }
-            else {
-                const item = input[value.base].find(matcherFunc) ?? null;
-                if (item === null && value.isNullable === false) {
-                    throw new Error("Value should exist as output schema defines it as nullable. Instead found null in array");
-                }
+            case "single": {
+                const item = singleJoinBase(joinType, matcherFunc);
+                assertIsNullable(item, value.isNullable, output, value.base);
                 if (item) {
                     final[finalKey] = {
                         ...item,
-                        ...relationMatcherJoiner(input, value, item),
+                        ...joiner(input, value, item),
                     };
                 }
+                break;
+            }
+            default: {
+                value.joinType;
+                throw new Error(`Unhandled join type. Relation matcher can not handle ${value.joinType}.`);
             }
         }
         return final;
     }, {});
 };
+export { joiner as relationMatcherJoiner };

package/dist/src/types/generic-bases.d.ts

@@ -1,4 +1,5 @@
 import type { RelationMapBase, RelationMapJoiner } from "./inputs";
-export type TInputBase = Record<string, Record<string, unknown> | null>;
+export type TInputBaseJoin = Record<string, unknown>;
+export type TInputBase = Record<string, TInputBaseJoin | null>;
 export type TJoinedFromBase = TInputBase[keyof TInputBase];
 export type TOutputBase<TInput extends TInputBase, TJoinedFrom extends TJoinedFromBase> = RelationMapBase<TInput, TJoinedFrom> & RelationMapJoiner<TInput, TJoinedFrom>;

package/dist/src/types/generic-less.d.ts

@@ -1,12 +1,16 @@
-import type { TInputBase } from "./generic-bases";
-export type Output<TJoinType extends "single" | "array" = "single" | "array"> = OutputJoins & {
-    base: keyof TInputBase;
+export type OutputBase<TJoinType extends "single" | "array" = "single" | "array"> = {
+    base: string;
     id: string;
     joinsTo: string;
     joinsFrom: string;
     joinType: TJoinType;
     isNullable?: false;
 };
+export type OutputRoot = OutputJoins & {
+    base: string;
+    id: string;
+};
+export type Output<TJoinType extends "single" | "array" = "single" | "array"> = OutputJoins & OutputBase<TJoinType>;
 export type OutputJoins = {
     [k: `_${string}`]: Output;
 };

package/dist/src/types/utils.d.ts

@@ -11,3 +11,6 @@ export type DeepNonNullable<T extends object> = {
 export type ArrayOrSingle<T, TType extends "single" | "array"> = TType extends "array" ? Array<T> : T;
 export type IsNullIfNull<TIsNull extends object | null, TReturn extends object | never = never> = TIsNull extends infer T ? (T & TReturn) | null : TIsNull & TReturn;
 export type ExtendsNull<T> = null extends T ? true : false;
+export type MaybeNull<T> = T | null;
+export type MaybeArray<T> = T | T[];
+export type SRecord<T> = Record<string, T>;

package/dist/src/utils/invertInput.d.ts

@@ -1,4 +1,5 @@
 import type { TInputBase } from "~/types/generic-bases";
-export type InvertedInput<TInput extends TInputBase = TInputBase> = Record<keyof TInput, TInput[keyof TInput][]>;
+export type InvertedInputRow<TInput extends TInputBase = TInputBase> = TInput[keyof TInput][];
+export type InvertedInput<TInput extends TInputBase = TInputBase> = Record<keyof TInput, InvertedInputRow<TInput>>;
 declare const invertInput: <TInput extends TInputBase>(inputs: TInputBase[]) => InvertedInput<TInput>;
 export default invertInput;

package/dist/src/utils/isNullable.d.ts

@@ -0,0 +1,3 @@
+import type { Output, OutputRoot } from "~/types";
+/** Asserts that if `isNullable` is false then item is not null. */
+export declare const assertIsNullable: (item: Record<string, unknown> | null, isNullable: false | undefined, output: Output | OutputRoot, base: string) => void;

package/dist/src/utils/isNullable.js

@@ -0,0 +1,6 @@
+/** Asserts that if `isNullable` is false then item is not null. */
+export const assertIsNullable = (item, isNullable, output, base) => {
+    if (isNullable === false && item === null) {
+        throw new Error(`Value should exist as output schema defines it as non-nullable. Instead found null in array. Found when joining ${base} onto ${output.base}.`);
+    }
+};

package/dist/src/utils/joins.d.ts

@@ -0,0 +1,5 @@
+import type { OutputBase } from "~/types";
+import type { InvertedInputRow } from "./invertInput";
+import { type MatcherFunc } from "./matcher";
+export declare const singleJoinBase: <TValue extends OutputBase<"single">>(input: InvertedInputRow, matcherFunc: MatcherFunc) => Record<string, unknown> | null;
+export declare const arrayJoinBase: <TValue extends OutputBase<"single">>(input: InvertedInputRow, matcherFunc: MatcherFunc) => Record<string, unknown>[];

package/dist/src/utils/joins.js

@@ -0,0 +1,9 @@
+import {} from "./matcher";
+export const singleJoinBase = (input, matcherFunc) => {
+    const item = input.find(matcherFunc) ?? null;
+    return item;
+};
+export const arrayJoinBase = (input, matcherFunc) => {
+    const item = input.filter(matcherFunc);
+    return item;
+};

package/dist/src/utils/matcher.d.ts

@@ -1,4 +1,4 @@
-import type { TInputBase } from "~/types/generic-bases";
-import type { InvertedInput } from "./invertInput";
+import type { TInputBase, TInputBaseJoin } from "~/types/generic-bases";
 import type { Output } from "~/types/generic-less";
-export declare const matcherFunc: <TInput extends TInputBase>(row: TInput[keyof TInput], value: Output) => (item: InvertedInput[keyof InvertedInput][number]) => boolean;
+export type MatcherFunc = (item: TInputBaseJoin | null) => item is TInputBaseJoin;
+export declare const createMatcherFunc: <TInput extends TInputBase>(row: TInput[keyof TInput], value: Output) => MatcherFunc;

package/dist/src/utils/matcher.js

@@ -1 +1,2 @@
-export const matcherFunc = (row, value) => (item) => row?.[value.joinsFrom] === item?.[value.joinsTo];
+export const createMatcherFunc = (row, value) => (item) => !!item &&
+    row?.[value.joinsFrom] === item?.[value.joinsTo];