prisma-ts-select 0.0.33

package/built/extend.d.cts

@@ -0,0 +1,451 @@
+import { Prisma } from '@prisma/client/extension';
+import { PrismaClient } from '@prisma/client';
+
+declare const DB: {
+	readonly User: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly email: "String";
+			readonly name: "?String";
+		};
+		readonly relations: {
+			readonly Post: {
+				readonly id: ["authorId", "lastModifiedById"];
+			};
+			readonly LikedPosts: {
+				readonly id: ["authorId"];
+			};
+		};
+	};
+	readonly Post: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly title: "String";
+			readonly content: "?String";
+			readonly published: "Boolean";
+			readonly authorId: "Int";
+			readonly lastModifiedById: "Int";
+		};
+		readonly relations: {
+			readonly User: {
+				readonly authorId: ["id"];
+				readonly lastModifiedById: ["id"];
+			};
+			readonly PostsImages: {
+				readonly id: ["postId"];
+			};
+			readonly LikedPosts: {
+				readonly id: ["postId"];
+			};
+		};
+	};
+	readonly PostsImages: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly url: "String";
+			readonly postId: "Int";
+		};
+		readonly relations: {
+			readonly Post: {
+				readonly postId: ["id"];
+			};
+		};
+	};
+	readonly LikedPosts: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly postId: "Int";
+			readonly authorId: "Int";
+		};
+		readonly relations: {
+			readonly Post: {
+				readonly postId: ["id"];
+			};
+			readonly User: {
+				readonly authorId: ["id"];
+			};
+		};
+	};
+	readonly MFId_Category: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly name: "String";
+		};
+		readonly relations: {
+			readonly MFId_CategoryPost: {
+				readonly id: ["categoryId"];
+			};
+		};
+	};
+	readonly MFId_CategoryPost: {
+		readonly fields: {
+			readonly categoryId: "Int";
+			readonly postId: "Int";
+		};
+		readonly relations: {
+			readonly MFId_Category: {
+				readonly categoryId: ["id"];
+			};
+			readonly MFId_Post: {
+				readonly postId: ["id"];
+			};
+		};
+	};
+	readonly MFId_Post: {
+		readonly relations: {
+			readonly MFId_CategoryPost: {
+				readonly id: ["postId"];
+			};
+		};
+		readonly fields: {
+			readonly id: "Int";
+			readonly title: "String";
+		};
+	};
+	readonly M2M_Post: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly title: "String";
+		};
+		readonly relations: {
+			readonly _M2M_CategoryToM2M_Post: {
+				readonly id: ["B"];
+			};
+		};
+	};
+	readonly _M2M_CategoryToM2M_Post: {
+		readonly fields: {
+			readonly A: "Int";
+			readonly B: "Int";
+		};
+		readonly relations: {
+			readonly M2M_Post: {
+				readonly B: ["id"];
+			};
+			readonly M2M_Category: {
+				readonly A: ["id"];
+			};
+		};
+	};
+	readonly M2M_Category: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly name: "String";
+		};
+		readonly relations: {
+			readonly _M2M_CategoryToM2M_Post: {
+				readonly id: ["A"];
+			};
+		};
+	};
+	readonly M2M_NC_Category: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly name: "String";
+		};
+		readonly relations: {
+			readonly _M2M_NC: {
+				readonly id: ["A"];
+			};
+		};
+	};
+	readonly _M2M_NC: {
+		readonly fields: {
+			readonly A: "Int";
+			readonly B: "Int";
+		};
+		readonly relations: {
+			readonly M2M_NC_Category: {
+				readonly A: ["id"];
+			};
+			readonly M2M_NC_Post: {
+				readonly B: ["id"];
+			};
+		};
+	};
+	readonly M2M_NC_Post: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly title: "String";
+		};
+		readonly relations: {
+			readonly _M2M_NC: {
+				readonly id: ["B"];
+			};
+		};
+	};
+	readonly MMM_Category: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly name: "String";
+		};
+		readonly relations: {
+			readonly _M2M_NC_M1: {
+				readonly id: ["A"];
+			};
+			readonly _M2M_NC_M2: {
+				readonly id: ["A"];
+			};
+		};
+	};
+	readonly _M2M_NC_M1: {
+		readonly fields: {
+			readonly A: "Int";
+			readonly B: "Int";
+		};
+		readonly relations: {
+			readonly MMM_Category: {
+				readonly A: ["id"];
+			};
+			readonly MMM_Post: {
+				readonly B: ["id"];
+			};
+		};
+	};
+	readonly _M2M_NC_M2: {
+		readonly fields: {
+			readonly A: "Int";
+			readonly B: "Int";
+		};
+		readonly relations: {
+			readonly MMM_Category: {
+				readonly A: ["id"];
+			};
+			readonly MMM_Post: {
+				readonly B: ["id"];
+			};
+		};
+	};
+	readonly MMM_Post: {
+		readonly fields: {
+			readonly id: "Int";
+			readonly title: "String";
+		};
+		readonly relations: {
+			readonly _M2M_NC_M1: {
+				readonly id: ["B"];
+			};
+			readonly _M2M_NC_M2: {
+				readonly id: ["B"];
+			};
+		};
+	};
+};
+type TDB = typeof DB;
+type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};
+type _db = DeepWriteable<TDB>;
+type DATABASE = {
+    [k in keyof _db]: {
+        table: k;
+        fields: {
+            [f in keyof _db[k]["fields"]]: StrTypeToTSType<_db[k]["fields"][f]>;
+        };
+        relations: _db[k]["relations"];
+    };
+}[keyof TDB];
+type JSONPrimitive = string | number | boolean | null;
+type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+type JSONObject = {
+    [member: string]: JSONValue;
+};
+type JSONArray = Array<JSONValue>;
+type StrTypeToTSType<str> = str extends string ? (GetTSType<RemoveNullChar<str>> | IsNullable<str>) : never;
+type GetTSType<str extends string> = str extends `String` ? string : str extends `BigInt` ? bigint : str extends `Int` ? number : str extends `Float` ? number : str extends `Decimal` ? number : str extends `Boolean` ? boolean : str extends `DateTime` ? Date : str extends `Bytes` ? Buffer : str extends `Json` ? JSONValue : "Unknown type";
+type IsNullable<str extends string> = str extends `?${string}` ? null : never;
+type RemoveNullChar<str extends string> = str extends `?${infer s}` ? s : str;
+type DBType = Record<string, {
+    fields: Record<string, string>;
+    relations: Record<string, Record<string, Array<string>>>;
+}>;
+type Filter<a, b> = a extends b ? a : never;
+type IsString<T> = T extends string ? T : never;
+type ValidSelect<Tables extends Array<TTables>> = "*" | GetOtherColumns<Tables>;
+type GetOtherColumns<Tables extends Array<TTables>> = Tables extends [infer T extends TTables, ...infer R extends Array<TTables>] ? GetColsBaseTable<T> | GetJoinCols<R[number]> : never;
+type TTables = DATABASE["table"];
+type TArrSources = [TTables, ...Array<TTables>];
+type ClauseType = Array<string | WhereCriteria<TArrSources, Record<string, any>>>;
+type Values = {
+    database: TTables;
+    selectDistinct?: true;
+    selects: Array<string>;
+    tables?: Array<{
+        table: TTables;
+        local: string;
+        remote: string;
+    }>;
+    limit?: number;
+    offset?: number;
+    where?: ClauseType;
+    having?: ClauseType;
+    groupBy?: Array<string>;
+    orderBy?: Array<`${string}${"" | " DESC" | " ASC"}`>;
+};
+declare class _fRun<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> {
+    protected db: PrismaClient;
+    protected values: Values;
+    constructor(db: PrismaClient, values: Values);
+    run(): Prisma.PrismaPromise<Array<TSelectRT>>;
+    getTables(): TSources;
+    getFields(): TFields;
+    getSQL(formatted?: boolean): string;
+}
+declare class _fOffset<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fRun<TSources, TFields, TSelectRT> {
+    offset(offset: number): _fRun<TSources, TFields, TSelectRT>;
+}
+declare class _fLimit<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fRun<TSources, TFields, TSelectRT> {
+    limit(limit: number): _fOffset<TSources, TFields, TSelectRT>;
+}
+type OrderBy<Tables extends TArrSources> = Tables extends [infer T extends TTables, ...infer R extends Array<TTables>] ? GetColsBaseTable<T> | GetJoinCols<R[number]> : never;
+declare class _fOrderBy<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fLimit<TSources, TFields, TSelectRT> {
+    orderBy(orderBy: Array<`${OrderBy<TSources>}${"" | " DESC" | " ASC"}`>): _fLimit<TSources, TFields, TSelectRT>;
+}
+type MergeItems<Field extends string, TSources extends TArrSources, TFields extends TFieldsType, IncTName extends boolean = false, TTables = TSources[number]> = Field extends "*" ? Prettify<IterateTables<TSources, TFields, IncTName>> : Field extends `${infer T extends TTables}.${infer F extends string}` ? Pick<TFields[T], F> : Pick<TFields[TSources[0]], Field>;
+type IterateTables<Tables extends Array<TTables>, TFields extends TFieldsType, IncTName extends boolean, acc extends Record<string, any> = {}> = Tables extends [infer T extends TTables, ...infer Rest extends Array<TTables>] ? [IncTName] extends [false] ? IterateTables<Rest, TFields, IncTName, acc & TFields[T]> : IterateTables<Rest, TFields, IncTName, acc & IterateTablesFromFields<T, TFields[T], IncTName>> : acc;
+type GenName<T extends string, F extends unknown, IncName extends boolean> = F extends string ? [IncName] extends [false] ? F : `${T}.${F}` : never;
+type IterateTablesFromFields<Table extends TTables, TFields extends Record<string, string>, IncTName extends boolean> = {
+    [f in keyof TFields as GenName<Table, f, IncTName>]: TFields[f];
+};
+declare class _fSelect<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fOrderBy<TSources, TFields, TSelectRT> {
+    select<TSelect extends ValidSelect<TSources>>(select: TSelect): _fSelect<TSources, TFields, TSelectRT & MergeItems<TSelect, TSources, TFields, false, TSources[number]> extends infer T ? { [K in keyof T]: (TSelectRT & MergeItems<TSelect, TSources, TFields, false, TSources[number]>)[K]; } : never>;
+}
+type CountKeys<T extends Array<string>, acc extends Array<true> = []> = T extends [string, ...infer R extends Array<string>] ? CountKeys<R, [...acc, true]> : acc["length"];
+declare class _fSelectDistinct<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fSelect<TSources, TFields, TSelectRT> {
+    selectDistinct(): _fSelect<TSources, TFields, TSelectRT>;
+    selectAll<TableCount = CountKeys<TSources>>(): _fOrderBy<TSources, TFields, IterateTables<TSources, TFields, TableCount extends 1 ? false : true, {}> extends infer T ? { [K in keyof T]: IterateTables<TSources, TFields, TableCount extends 1 ? false : true, {}>[K]; } : never>;
+}
+declare class _fHaving<TSources extends TArrSources, TFields extends TFieldsType> extends _fSelectDistinct<TSources, TFields> {
+    having<const TCriteria extends WhereCriteria<TSources, TFields>>(criteria: TCriteria): _fSelectDistinct<TSources, TFields, {}>;
+}
+declare class _fGroupBy<TSources extends TArrSources, TFields extends TFieldsType> extends _fHaving<TSources, TFields> {
+    groupBy<TSelect extends GetOtherColumns<TSources>>(groupBy: Array<TSelect>): _fHaving<TSources, TFields>;
+}
+type OptionalRecord<K extends PropertyKey, V> = {
+    [key in K]?: V;
+};
+type OptionalObject<K extends Record<PropertyKey, unknown>> = {
+    [key in keyof K]?: K[key];
+};
+type COND_NUMERIC<key extends PropertyKey, keyType> = OptionalRecord<key, keyType> | OptionalRecord<key, {
+    op: 'IN' | 'NOT IN';
+    values: Array<keyType>;
+}> | OptionalRecord<key, {
+    op: 'BETWEEN';
+    values: [keyType, keyType];
+}> | OptionalRecord<key, {
+    op: '>' | '>=' | '<' | '<=' | '!=';
+    value: keyType;
+}>;
+type COND_STRING<key extends PropertyKey> = OptionalRecord<key, string> | OptionalRecord<key, {
+    op: 'IN' | 'NOT IN';
+    values: Array<string>;
+}> | OptionalRecord<key, {
+    op: 'LIKE' | 'NOT LIKE';
+    value: string;
+}> | OptionalRecord<key, {
+    op: '!=';
+    value: string;
+}>;
+type COND_DATETIME<key extends PropertyKey, keyType> = OptionalRecord<key, keyType> | OptionalRecord<key, {
+    op: 'IN' | 'NOT IN';
+    values: Array<keyType>;
+}> | OptionalRecord<key, {
+    op: 'BETWEEN';
+    values: [keyType, keyType];
+}> | OptionalRecord<key, {
+    op: '>' | '>=' | '<' | '<=' | '!=';
+    value: keyType;
+}>;
+type COND_BOOLEAN<key extends PropertyKey, keyType> = OptionalRecord<key, keyType> | OptionalRecord<key, {
+    op: '!=';
+    value: keyType;
+}>;
+type COND_NULL<key extends PropertyKey, keyType> = keyType extends null ? OptionalRecord<key, {
+    op: 'IS NULL' | 'IS NOT NULL';
+}> : never;
+type SQLCondition<T> = Prettify<{
+    [K in keyof T]?: (Exclude<T[K], null> extends number ? COND_NUMERIC<K, Exclude<T[K], null>> : Exclude<T[K], null> extends bigint ? COND_NUMERIC<K, Exclude<T[K], null>> : Exclude<T[K], null> extends string ? COND_STRING<K> : Exclude<T[K], null> extends boolean ? COND_BOOLEAN<K, Exclude<T[K], null>> : Exclude<T[K], null> extends Date ? COND_DATETIME<K, Exclude<T[K], null>> : "Unsupported Data Type") | COND_NULL<K, T[K]>;
+}[keyof T]>;
+type TableFieldType<Table extends string, Fields extends Record<string, any>> = {
+    [f in keyof Fields as CombineToString<f, Table>]: Fields[f];
+};
+type LogicalOperator = '$AND' | '$OR' | '$NOT' | "$NOR";
+type WhereCriteria<T extends TArrSources, TFields extends TFieldsType, F = WhereCriteria_Fields<T, TFields>> = F & {
+    [k in LogicalOperator]?: [WhereCriteria<T, TFields, F>, ...Array<WhereCriteria<T, TFields, F>>];
+};
+type WhereCriteria_Fields<T extends Array<string>, TFields extends TFieldsType, acc = {}> = T extends readonly [infer HEAD, ...infer Rest] ? HEAD extends string ? Rest extends Array<string> ? WhereCriteria_Fields<Rest, TFields, OptionalObject<acc & (TableFieldType<HEAD, TFields[HEAD]> | SQLCondition<TableFieldType<HEAD, TFields[HEAD]>>)>> : WhereCriteria_Fields<[], TFields, OptionalObject<acc & (TableFieldType<HEAD, TFields[HEAD]> | SQLCondition<TableFieldType<HEAD, TFields[HEAD]>>)>> : never : acc;
+type OnlyNull<T, R> = T extends null ? R : never;
+type FindColsWithNull<TFields extends TFieldsType> = Prettify<{
+    [Table in keyof TFields]: {
+        [Field in keyof TFields[Table]]: OnlyNull<TFields[Table][Field], CombineToString<Field, Table>>;
+    }[keyof TFields[Table]];
+}[keyof TFields]>;
+type NO_START_WITH_WHERE<RAW extends string> = Uppercase<TRIM<RAW>> extends `WHERE ${string}` ? "Please do not start with `WHERE`" : RAW;
+type TRIM<S extends string> = S extends ` ${infer S2}` ? TRIM<S2> : S;
+declare class _fWhere<TSources extends TArrSources, TFields extends TFieldsType> extends _fGroupBy<TSources, TFields> {
+    whereNotNull<const TColWithNull extends FindColsWithNull<TFields>>(col: TColWithNull): _fWhere<TSources, TColWithNull extends `${infer table}.${infer col}` ? Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>>[K_1]; } : never) extends infer T ? { [K in keyof T]: (Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>>[K_1]; } : never))[K]; } : never : never>;
+    whereIsNull<const TColWithNull extends FindColsWithNull<TFields>>(col: TColWithNull): _fWhere<TSources, TColWithNull extends `${infer table}.${infer col}` ? Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>>[K_1]; } : never) extends infer T ? { [K in keyof T]: (Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>>[K_1]; } : never))[K]; } : never : never>;
+    where<const TCriteria extends WhereCriteria<TSources, TFields>>(criteria: TCriteria): _fGroupBy<TSources, TFields>;
+    whereRaw<RAW extends string>(where: NO_START_WITH_WHERE<RAW>): _fGroupBy<TSources, TFields>;
+}
+type GetFieldsFromTable<TDBBase extends TTables> = Extract<DATABASE, {
+    table: TDBBase;
+}>["fields"];
+type GetColsBaseTable<TDBBase extends TTables> = TDBBase extends any ? keyof GetFieldsFromTable<TDBBase> : never;
+type GetJoinCols<TDBBase extends TTables> = TDBBase extends any ? IterateFields<TDBBase, IsString<GetColsBaseTable<TDBBase>>> : never;
+type IterateFields<TDBBase extends TTables, F extends string> = `${TDBBase}.${F}`;
+type Relations<Table extends TTables> = Extract<DATABASE, {
+    table: Table;
+}>["relations"];
+type AvailableJoins<Tables extends Array<TTables>, acc extends TTables = never> = Tables extends [infer T extends TTables, ...infer Rest extends Array<TTables>] ? AvailableJoins<Rest, acc | keyof Relations<T>> : acc;
+type SafeJoins<TNewJoin extends TTables, TJoins extends Array<TTables>, TRelations = Relations<TNewJoin>> = {
+    [k in keyof TRelations as Filter<k, TJoins[number]>]: TRelations[k];
+};
+type CombineToString<A extends unknown, T extends unknown> = A extends string ? T extends string ? `${T}.${A}` : never : never;
+type GetUnionOfRelations<TSafe> = {
+    [T in keyof TSafe]: {
+        [TLocal in keyof TSafe[T]]: [
+            TLocal,
+            T extends string ? TSafe[T][TLocal] extends Array<string> ? CombineToString<TSafe[T][TLocal][number], T> : never : never
+        ];
+    }[keyof TSafe[T]];
+}[keyof TSafe];
+type ValidStringTuple<T> = T extends [string, string] ? T : never;
+type find<T extends [string, string], toFind extends string> = T extends [infer col1, infer col2] ? col1 extends toFind ? col2 : never : never;
+type RemoveNullable<T extends string> = T extends `?${infer R}` ? R : T;
+type SwapKeysAndValues<T extends Record<string, any>> = {
+    [K in keyof T as RemoveNullable<T[K]>]: K;
+};
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type FieldsByTableByType = Prettify<{
+    [Table in TTables]: SwapKeysAndValues<_db[Table]["fields"]>;
+}>;
+type GetTypes = {
+    [Type in keyof FieldsByTableByType as keyof FieldsByTableByType[Type]]: {};
+};
+type FieldsByTypeByTable = Prettify<{
+    [Type in keyof GetTypes]: {
+        [Table in keyof FieldsByTableByType as [FieldsByTableByType[Table][Filter<keyof FieldsByTableByType[Table], Type>]] extends [never] ? never : Table]: FieldsByTableByType[Table][Filter<keyof FieldsByTableByType[Table], Type>];
+    };
+}>;
+type GetColumnType<Table extends TTables, Col1 extends keyof _db[Table]["fields"]> = RemoveNullChar<IsString<_db[Table]["fields"][Col1]>>;
+type GetJoinOnColsType<Type extends string, TSources extends Array<TTables>> = GetJoinColsType<TSources[number], Type>;
+type GetColsFromTableType<TDBBase extends TTables, Type extends string> = FieldsByTypeByTable[Loop<keyof FieldsByTypeByTable, Type>][TDBBase];
+type Loop<Keys extends string, Type extends string> = Keys extends Type ? Type : never;
+type GetJoinColsType<TDBBase extends TTables, Type extends string> = IterateFields<TDBBase, IsString<GetColsFromTableType<TDBBase, Type>>>;
+type TFieldsType = Record<string, Record<string, any>>;
+declare class _fJoin<TSources extends TArrSources, TFields extends TFieldsType> extends _fWhere<TSources, TFields> {
+    join<Table extends AvailableJoins<TSources>, TJoinCols extends [string, string] = ValidStringTuple<GetUnionOfRelations<SafeJoins<Table, TSources>>>, TCol1 extends TJoinCols[0] = never>(table: Table, field: TCol1, reference: find<TJoinCols, TCol1>): _fJoin<[...TSources, Table], TFields & Record<Table, GetFieldsFromTable<Table>> extends infer T ? { [K in keyof T]: (TFields & Record<Table, GetFieldsFromTable<Table>>)[K]; } : never>;
+    joinUnsafeTypeEnforced<Table extends AvailableJoins<TSources>, TCol1 extends GetColsBaseTable<Table>, TCol2 extends GetJoinOnColsType<GetColumnType<Table, TCol1>, [...TSources, Table]>>(table: Table, field: TCol1, reference: TCol2): _fJoin<[...TSources, Table], TFields & Record<Table, GetFieldsFromTable<Table>>>;
+    joinUnsafeIgnoreType<Table extends AvailableJoins<TSources>, TCol2 extends GetJoinCols<TSources[number]>>(table: Table, field: GetColsBaseTable<Table>, reference: TCol2): _fJoin<[...TSources, Table], TFields & Record<Table, GetFieldsFromTable<Table>>>;
+}
+declare const _default: {
+    client: {
+        $from<T extends TTables>(table: T): _fJoin<[T], Record<T, GetFieldsFromTable<T>>>;
+    };
+};
+
+export { type DBType, type GetUnionOfRelations, type JSONArray, type JSONObject, type JSONPrimitive, type JSONValue, type RemoveNullChar, type SafeJoins, type TTables, _default as default };