relation-matcher 1.0.6 → 1.0.8

package/package.json

@@ -1,12 +1,18 @@
 {
 	"name": "relation-matcher",
-	"version": "1.0.6",
+	"version": "1.0.8",
 	"description": "A utility to convert table data (such as out of a SQL query) into structured JSON.",
 	"license": "ISC",
 	"author": "",
 	"type": "module",
 	"main": "dist/src/index.js",
 	"types": "dist/src/index.d.ts",
+	"exports": {
+		".": "./dist/src/index.js",
+		"./types": "./dist/src/types/index.js",
+		"./source": "./src/index.ts",
+		"./source/types": "./src/types/index.ts"
+	},
 	"private": false,
 	"scripts": {
 		"test": "jest",

package/src/index.ts

@@ -99,7 +99,7 @@ export const relationMatcherRoot = <
 		return final;
 	}, {});
 
-	return baseItems as Record<
+	return baseItems as unknown as Record<
 		string,
 		RelationMapperReturnRoot<TInput, TOutputRoot>
 	>;

package/src/testing/test-data.ts

@@ -1,4 +1,5 @@
 import type { RelationMapRoot } from "~/types/inputs";
+import type { Simplify } from "~/types/utils";
 
 export const testData = [
 	{

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export type * from "./generic-bases";
+export type * from "./generic-less";
+export type * from "./return";
+export type * from "./typetest";
+export type * from "./utils";

package/src/types/inputs.ts

@@ -3,8 +3,8 @@ import type { TInputBase, TJoinedFromBase } from "./generic-bases";
 export type RelationMapRoot<TInput extends TInputBase> = {
 	[k in keyof TInput]: {
 		base: k;
-		id: keyof TInput[k];
-	} & RelationMapJoiner<TInput, TInput[k]>;
+		id: keyof NonNullable<TInput[k]>;
+	} & RelationMapJoiner<TInput, NonNullable<TInput[k]>>;
 }[keyof TInput];
 
 export type RelationMapBase<
@@ -13,9 +13,10 @@ export type RelationMapBase<
 > = {
 	[k in keyof TInput]: {
 		base: k;
-		id: keyof TInput[k];
-		joinsTo: keyof TInput[k];
-		joinsFrom: keyof TJoinedFrom;
+		/** The id that uniqueness is checked against. Either the primary key of the table, or the id you are joining **to** on a join table. */
+		id: keyof NonNullable<TInput[k]>;
+		joinsTo: keyof NonNullable<TInput[k]>;
+		joinsFrom: keyof NonNullable<TJoinedFrom>;
 		joinType: "single" | "array";
 	} & RelationMapJoiner<TInput, TInput[k]>;
 }[keyof TInput];
@@ -24,6 +25,6 @@ export type RelationMapJoiner<
 	TInput extends TInputBase,
 	TJoinedFrom extends TJoinedFromBase,
 > = {
-	[k: `_${string}`]: RelationMapJoiner<TInput, TJoinedFrom> &
-		RelationMapBase<TInput, TJoinedFrom>;
+	[k: `_${string}`]: RelationMapBase<TInput, TJoinedFrom> &
+		RelationMapJoiner<TInput, TJoinedFrom>;
 };

package/src/types/return.ts

@@ -1,27 +1,61 @@
 import type { TInputBase, TJoinedFromBase, TOutputBase } from "./generic-bases";
 import type { RelationMapRoot } from "./inputs";
-import type { NoUnderscore } from "./utils";
+import type { ExtendsNull, NoUnderscore, Simplify } from "./utils";
 
 export type RelationMapperReturnRoot<
 	TInput extends TInputBase,
 	TOutput extends RelationMapRoot<TInput>,
+> = Simplify<
+	{
+		[inputKey in keyof TInput]: ExtendsNull<
+			TInput[TOutput["base"]]
+		> extends true
+			? Simplify<
+					TInput[TOutput["base"]] &
+						RelationMapperReturnJoinRoot<TInput, TOutput, inputKey>
+				> | null
+			: Simplify<
+					TInput[TOutput["base"]] &
+						RelationMapperReturnJoinRoot<TInput, TOutput, inputKey>
+				>;
+	}[keyof TInput]
+>;
+
+export type RelationMapperReturnJoinRoot<
+	TInput extends TInputBase,
+	TOutput extends RelationMapRoot<TInput>,
+	TInputKey extends keyof TInput,
 > = {
-	[inputKey in keyof TInput]: TInput[TOutput["base"]] & {
-		[outputKey in NoUnderscore<keyof TOutput>]: RelationMapperReturn<
+	[outputKey in NoUnderscore<keyof TOutput>]: Simplify<
+		RelationMapperReturn<
 			TInput,
-			TInput[inputKey],
+			TInput[TInputKey],
 			TOutput[`_${outputKey}`]
-		>;
-	};
-}[keyof TInput];
+		>
+	>;
+};
 
 /** Fill current object with value specified in base */
 export type RelationMapperReturn<
 	TInput extends TInputBase,
 	TJoinedFrom extends TJoinedFromBase,
 	TOutput extends TOutputBase<TInput, TJoinedFrom>,
-> = TInput[TOutput["base"]] &
-	RelationMapperReturnJoin<TInput, TJoinedFrom, TOutput>;
+> = TOutput["joinType"] extends "array"
+	? Array<
+			Simplify<
+				TInput[TOutput["base"]] &
+					RelationMapperReturnJoin<TInput, TJoinedFrom, TOutput>
+			>
+		>
+	: ExtendsNull<TInput[TOutput["base"]]> extends true
+		? Simplify<
+				TInput[TOutput["base"]] &
+					RelationMapperReturnJoin<TInput, TJoinedFrom, TOutput>
+			> | null
+		: Simplify<
+				TInput[TOutput["base"]] &
+					RelationMapperReturnJoin<TInput, TJoinedFrom, TOutput>
+			>;
 
 /** Takes underscored values (joins) and replaces their values with the actual output. */
 export type RelationMapperReturnJoin<

package/src/types/typetest.ts

@@ -1,46 +1,76 @@
 import type { RelationMapperReturnRoot } from "./return";
+import type { DeepSimplify, ExtendsNull, Simplify } from "./utils";
 
-export type A = RelationMapperReturnRoot<
+export type A = DeepSimplify<
+	RelationMapperReturnRoot<
+		{
+			team: {
+				created_at: Date;
+				updated_at: Date | null;
+				id: string;
+				team_name: string;
+				club_name: string;
+				club_postcode: string;
+			};
+			team_to_user: {
+				created_at: Date;
+				updated_at: Date | null;
+				user_clerk_id: string;
+				team_id: string;
+			} | null;
+		},
+		{
+			base: "team";
+			id: "id";
+
+			_teamToUser: {
+				base: "team_to_user";
+				id: "user_clerk_id";
+				joinsTo: "team_id";
+				joinsFrom: "id";
+				joinType: "single";
+
+				_team: {
+					base: "team";
+					id: "id";
+					joinsFrom: "team_id";
+					joinsTo: "id";
+					joinType: "array";
+				};
+			};
+		}
+	>,
+	Date | null | number
+>;
+
+type B = RelationMapperReturnRoot<
 	{
-		team: {
-			created_at: Date;
-			updated_at: Date | null;
-			id: string;
-			team_name: string;
-			club_name: string;
-			club_postcode: string;
+		user: {
+			clerk_id: string;
 		};
 		team_to_user: {
-			created_at: Date;
-			updated_at: Date | null;
-			user_clerk_id: string;
 			team_id: string;
-		};
+			user_clerk_id: string;
+		} | null;
 	},
 	{
-		base: "team";
-		id: "id";
+		base: "user";
+		id: "clerk_id";
 
 		_teamToUser: {
 			base: "team_to_user";
-			id: "user_clerk_id";
-			joinsTo: "team_id";
-			joinsFrom: "id";
+			id: "team_id";
+			joinsFrom: "clerk_id";
+			joinsTo: "user_clerk_id";
 			joinType: "single";
-
-			_sar: {
-				base: "team";
-				id: "id";
-				joinsFrom: "team_id";
-				joinsTo: "id";
-				joinType: "array";
-			};
 		};
 	}
 >;
 
-// type B = {
-// 	team: Schema["Team"]["$inferSelect"][];
-// 	team_to_user: Schema["TeamToUser"]["$inferSelect"][];
-// };
+type C = Simplify<B>;
 //   ^?
+
+type D = ExtendsNull<{
+	team_id: string;
+	user_clerk_id: string;
+} | null>;

package/src/types/utils.ts

@@ -2,15 +2,27 @@ export type Simplify<T> = {
 	[k in keyof T]: T[k];
 } & {};
 
-export type DeepSimplify<T> = {
-	[k in keyof T]: T[k] extends Record<
-		string | number | symbol,
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		(...args: any[]) => any
-	>
-		? T[k]
-		: DeepSimplify<T[k]>;
+export type DeepSimplify<TInput, TDontSimplify> = {
+	[k in keyof TInput]: TInput[k] extends TDontSimplify
+		? TInput[k]
+		: DeepSimplify<TInput[k], TDontSimplify>;
 } & {};
 
 export type NoUnderscore<T extends string | number | symbol> =
 	T extends `_${infer Result}` ? Result : never;
+
+export type DeepNonNullable<T extends object> = {
+	[k in keyof T]: T[k] extends infer NonNull | null ? NonNull : T[k];
+};
+
+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;