relation-matcher 1.0.6 → 1.0.7

package/dist/src/types/index.d.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/dist/src/types/index.js

@@ -0,0 +1 @@
+export {};

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

@@ -2,18 +2,19 @@ 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<TInput extends TInputBase, TJoinedFrom extends TJoinedFromBase> = {
     [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];
 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/dist/src/types/return.d.ts

@@ -1,13 +1,14 @@
 import type { TInputBase, TJoinedFromBase, TOutputBase } from "./generic-bases";
 import type { RelationMapRoot } from "./inputs";
-import type { NoUnderscore } from "./utils";
-export type RelationMapperReturnRoot<TInput extends TInputBase, TOutput extends RelationMapRoot<TInput>> = {
-    [inputKey in keyof TInput]: TInput[TOutput["base"]] & {
-        [outputKey in NoUnderscore<keyof TOutput>]: RelationMapperReturn<TInput, TInput[inputKey], TOutput[`_${outputKey}`]>;
-    };
-}[keyof TInput];
+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> = {
+    [outputKey in NoUnderscore<keyof TOutput>]: Simplify<RelationMapperReturn<TInput, TInput[TInputKey], TOutput[`_${outputKey}`]>>;
+};
 /** 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>;
+export type RelationMapperReturn<TInput extends TInputBase, TJoinedFrom extends TJoinedFromBase, TOutput extends TOutputBase<TInput, TJoinedFrom>> = 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<TInput extends TInputBase, TJoinedFrom extends TJoinedFromBase, TOutput extends TOutputBase<TInput, TJoinedFrom>> = {
     [k in NoUnderscore<keyof TOutput>]: RelationMapperReturn<TInput, TJoinedFrom, TOutput[`_${k}`]>;

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

@@ -1,5 +1,6 @@
 import type { RelationMapperReturnRoot } from "./return";
-export type A = RelationMapperReturnRoot<{
+import type { DeepSimplify } from "./utils";
+export type A = DeepSimplify<RelationMapperReturnRoot<{
     team: {
         created_at: Date;
         updated_at: Date | null;
@@ -13,7 +14,7 @@ export type A = RelationMapperReturnRoot<{
         updated_at: Date | null;
         user_clerk_id: string;
         team_id: string;
-    };
+    } | null;
 }, {
     base: "team";
     id: "id";
@@ -23,7 +24,7 @@ export type A = RelationMapperReturnRoot<{
         joinsTo: "team_id";
         joinsFrom: "id";
         joinType: "single";
-        _sar: {
+        _team: {
             base: "team";
             id: "id";
             joinsFrom: "team_id";
@@ -31,4 +32,4 @@ export type A = RelationMapperReturnRoot<{
             joinType: "array";
         };
     };
-}>;
+}>, Date | null | number>;

package/dist/src/types/typetest.js

@@ -1,6 +1 @@
 export {};
-// type B = {
-// 	team: Schema["Team"]["$inferSelect"][];
-// 	team_to_user: Schema["TeamToUser"]["$inferSelect"][];
-// };
-//   ^?

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

@@ -1,7 +1,13 @@
 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, (...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;