relation-matcher 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "relation-matcher",
-	"version": "1.1.0",
+	"version": "1.1.2",
 	"description": "A utility to convert table data (such as out of a SQL query) into structured JSON.",
 	"license": "ISC",
 	"author": "",

package/src/index.ts

@@ -1,18 +1,21 @@
-import type { TInputBase } from "./types/generic-bases";
-import type { Output } from "./types/generic-less";
-import type { RelationMapRoot } from "./types/inputs";
-import type { RelationMapperReturnRoot } from "./types/return";
+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 invertInput, { type InvertedInput } 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 = <
 	TInput extends TInputBase,
-	TOutputRoot extends RelationMapRoot<TInput>,
+	TOutputRoot extends Root<TInput>,
 >(
 	inputs: TInput[],
 	output: TOutputRoot,
-): Record<string, RelationMapperReturnRoot<TInput, TOutputRoot>> => {
+): SRecord<ReturnRoot<TInput, TOutputRoot>> => {
 	if (!inputs.length) return {};
 
 	if (!Array.isArray(inputs)) {
@@ -21,140 +24,101 @@ export const relationMatcherRoot = <
 
 	const invertedInput = invertInput<TInput>(inputs);
 
-	const baseItems = invertedInput[output.base].reduce<
-		Record<string, TInput[TOutputRoot["base"]]>
-	>((final, row) => {
-		if (!row) {
-			return final;
-		}
-
-		const relations = Object.entries(output).reduce<
-			Record<string, unknown>
-		>((final, [key, value]) => {
-			if (typeof value === "object") {
-				const finalKey = getJoinFinalKey(key);
-
-				if (value.joinType === "array") {
-					const baseObjArr = invertedInput[value.base]!.filter(
-						matcherFunc(row, value as Output),
-					) as TInputBase[string][];
-
-					final[finalKey] = Object.values(
-						baseObjArr.reduce<
-							Record<string, NonNullable<TInputBase[string]>>
-						>((final, item) => {
-							if (!item) return final;
-
-							final[item[value.id as string] as string] = {
-								...item,
-								...relationMatcherJoiner(
-									invertedInput,
-									value as Output,
-									item,
-								),
-							};
-
-							return final;
-						}, {}),
-					);
-				} else {
-					const item =
-						(invertedInput[value.base]!.find(
-							matcherFunc(row, value as Output),
-						) as TInputBase[string] | undefined) ?? null;
-
-					if (item) {
-						final[finalKey] = {
-							...item,
-							...relationMatcherJoiner(
-								invertedInput,
-								value as Output,
-								item,
-							),
-						};
-					}
-				}
+	type BaseItems = SRecord<TInput[TOutputRoot["base"]]>;
+	const baseItems = invertedInput[output.base].reduce<BaseItems>(
+		(final, inputRow) => {
+			if (!inputRow) {
+				return final;
 			}
 
-			return final;
-		}, {}) as TInput[TOutputRoot["base"]];
+			const relations = joiner(
+				invertedInput,
+				output as OutputRoot,
+				inputRow,
+			);
 
-		final[row[output.id as string] as string] = { ...row, ...relations };
+			const rowId = inputRow[output.id as string];
 
-		return final;
-	}, {});
+			final[rowId as string] = {
+				...inputRow,
+				...relations,
+			};
+
+			return final;
+		},
+		{},
+	);
 
 	return baseItems as unknown as Record<
 		string,
-		RelationMapperReturnRoot<TInput, TOutputRoot>
+		ReturnRoot<TInput, TOutputRoot>
 	>;
 };
 
 export const relationMatcher = relationMatcherRoot;
 export default relationMatcherRoot;
 
-const relationMatcherJoiner = (
+const joiner = (
 	input: InvertedInput,
-	output: Output,
-	joiningFrom: Record<string, unknown>,
+	output: Output | OutputRoot,
+	joiningFrom: SRecord<unknown>,
 ) => {
-	return Object.entries(output).reduce<
-		Record<string, TInputBase[string] | TInputBase[string][] | null>
-	>((final, [key, value]) => {
-		if (typeof value === "object") {
-			const finalKey = getJoinFinalKey(key);
+	type Return = SRecord<MaybeArray<MaybeNull<TInputBaseJoin>>>;
+	return Object.entries(output).reduce<Return>((final, [key, value]) => {
+		if (typeof value !== "object") return final;
 
-			const matcherFunc = (
-				item: InvertedInput[keyof InvertedInput][number],
-			) => item?.[value.joinsTo] === joiningFrom[value.joinsFrom];
+		const finalKey = getJoinFinalKey(key);
+		const matcherFunc = createMatcherFunc(joiningFrom, value);
 
-			if (!input[value.base])
-				throw new Error(`Input is missing rows for ${value.base}.`);
+		const joinType = input[value.base];
 
-			if (value.joinType === "array") {
-				const baseObjArr = input[value.base]!.filter(
-					matcherFunc,
-				) as InvertedInput[number];
+		if (!joinType)
+			throw new Error(`Input is missing rows for ${value.base}.`);
 
-				final[finalKey] = Object.values(
-					baseObjArr.reduce<
-						Record<string, NonNullable<TInputBase[string]>>
-					>((final, item) => {
-						if (!item) return final;
-
-						const propertyKey = item[value.id as string] as string;
+		switch (value.joinType) {
+			case "array": {
+				const baseObjArr = arrayJoinBase(joinType, matcherFunc);
 
-						if (final[propertyKey]) return final;
+				type FinalRow = SRecord<NonNullable<TInputBase[string]>>;
+				final[finalKey] = Object.values(
+					baseObjArr.reduce<FinalRow>((final, item) => {
+						const propertyKey = item[value.id] as string;
 
-						final[propertyKey] = {
+						final[propertyKey] ??= {
 							...item,
-							...relationMatcherJoiner(input, value, item),
+							...joiner(input, value, item),
 						};
 
 						return final;
 					}, {}),
 				);
-			} else {
-				const item =
-					(input[value.base]!.find(matcherFunc) as
-						| InvertedInput[string][number]
-						| undefined) ?? 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",
-					);
-				}
+
+				break;
+			}
+			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 satisfies never;
+				throw new Error(
+					`Unhandled join type. Relation matcher can not handle ${value.joinType}.`,
+				);
 			}
 		}
 
 		return final;
 	}, {});
 };
+
+export { joiner as relationMatcherJoiner };

package/src/types/generic-bases.ts

@@ -1,6 +1,7 @@
 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,

package/src/types/generic-less.ts

@@ -1,14 +1,19 @@
 import type { TInputBase } from "./generic-bases";
 
+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 & {
-		base: keyof TInputBase;
-		id: string;
-		joinsTo: string;
-		joinsFrom: string;
-		joinType: TJoinType;
-		isNullable?: false;
-	};
+	OutputJoins & OutputBase<TJoinType>;
 
 export type OutputJoins = {
 	[k: `_${string}`]: Output;

package/src/types/utils.ts

@@ -26,3 +26,8 @@ export type IsNullIfNull<
 > = 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/src/utils/invertInput.ts

@@ -1,8 +1,10 @@
 import type { TInputBase } from "~/types/generic-bases";
 
+export type InvertedInputRow<TInput extends TInputBase = TInputBase> =
+	TInput[keyof TInput][];
 export type InvertedInput<TInput extends TInputBase = TInputBase> = Record<
 	keyof TInput,
-	TInput[keyof TInput][]
+	InvertedInputRow<TInput>
 >;
 
 const invertInput = <TInput extends TInputBase>(

package/src/utils/isNullable.ts

@@ -0,0 +1,15 @@
+import type { Output, OutputRoot } from "~/types";
+
+/** Asserts that if `isNullable` is false then item is not null. */
+export const assertIsNullable = (
+	item: Record<string, unknown> | null,
+	isNullable: false | undefined,
+	output: Output | OutputRoot,
+	base: string,
+) => {
+	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/src/utils/joins.ts

@@ -0,0 +1,22 @@
+import type { OutputBase, TInputBase } from "~/types";
+import type { InvertedInput, InvertedInputRow } from "./invertInput";
+import { type MatcherFunc } from "./matcher";
+
+export const singleJoinBase = <TValue extends OutputBase<"single">>(
+	input: InvertedInputRow,
+	matcherFunc: MatcherFunc,
+): Record<string, unknown> | null => {
+	const item =
+		(input.find(matcherFunc) as TInputBase[string] | undefined) ?? null;
+
+	return item;
+};
+
+export const arrayJoinBase = <TValue extends OutputBase<"single">>(
+	input: InvertedInputRow,
+	matcherFunc: MatcherFunc,
+): Record<string, unknown>[] => {
+	const item = input.filter(matcherFunc);
+
+	return item;
+};

package/src/utils/matcher.ts

@@ -1,8 +1,16 @@
-import type { TInputBase } from "~/types/generic-bases";
+import type { TInputBase, TInputBaseJoin } from "~/types/generic-bases";
 import type { InvertedInput } from "./invertInput";
 import type { Output } from "~/types/generic-less";
 
-export const matcherFunc =
-	<TInput extends TInputBase>(row: TInput[keyof TInput], value: Output) =>
-	(item: InvertedInput[keyof InvertedInput][number]) =>
+export type MatcherFunc = (
+	item: TInputBaseJoin | null,
+) => item is TInputBaseJoin;
+
+export const createMatcherFunc =
+	<TInput extends TInputBase>(
+		row: TInput[keyof TInput],
+		value: Output,
+	): MatcherFunc =>
+	(item): item is TInputBaseJoin =>
+		!!item &&
 		row?.[value.joinsFrom as string] === item?.[value.joinsTo as string];