appflare 0.2.4 → 0.2.7

package/cli/templates/handlers/generators/types/query-definitions/filter-and-where-types.ts

@@ -0,0 +1,168 @@
+export function generateFilterAndWhereTypesSection(): string {
+	return `type Primitive = string | number | boolean | Date;
+type NonNil<T> = Exclude<T, null | undefined>;
+type Friendly<T> = T extends Date ? Date | number : T;
+type Comparable<T> = Friendly<Extract<NonNil<T>, Primitive>>;
+type RegexOperand<T> = T extends string ? string : never;
+
+type GeoPoint = {
+	latitude: number;
+	longitude: number;
+};
+
+type GeoCoordinates = {
+	type?: "Point";
+	coordinates: [number, number] | readonly [number, number];
+};
+
+type GeoWithinOperand = {
+	$geometry: GeoPoint | GeoCoordinates;
+	latitudeField?: string;
+	longitudeField?: string;
+	$minDistance?: number;
+	$maxDistance?: number;
+	gt?: number;
+	gte?: number;
+	lt?: number;
+	lte?: number;
+	$gt?: number;
+	$gte?: number;
+	$lt?: number;
+	$lte?: number;
+};
+
+type GeoWithinOperandForField<TFieldKey extends string> = Omit<
+	GeoWithinOperand,
+	"latitudeField" | "longitudeField"
+> & {
+	latitudeField?: TFieldKey;
+	longitudeField?: TFieldKey;
+};
+
+type FieldOperators<T, TFieldKey extends string = string> = {
+	eq?: Friendly<NonNil<T>>;
+	$eq?: Friendly<NonNil<T>>;
+	ne?: Friendly<NonNil<T>>;
+	$ne?: Friendly<NonNil<T>>;
+	in?: ReadonlyArray<Friendly<NonNil<T>>>;
+	$in?: ReadonlyArray<Friendly<NonNil<T>>>;
+	nin?: ReadonlyArray<Friendly<NonNil<T>>>;
+	$nin?: ReadonlyArray<Friendly<NonNil<T>>>;
+	gt?: Comparable<T>;
+	$gt?: Comparable<T>;
+	gte?: Comparable<T>;
+	$gte?: Comparable<T>;
+	lt?: Comparable<T>;
+	$lt?: Comparable<T>;
+	lte?: Comparable<T>;
+	$lte?: Comparable<T>;
+	exists?: boolean;
+	regex?: RegexOperand<T>;
+	$options?: string;
+	geoWithin?: GeoWithinOperandForField<TFieldKey>;
+};
+
+type WhereFieldValue<T, TFieldKey extends string> =
+	| Friendly<NonNil<T>>
+	| FieldOperators<T, TFieldKey>;
+
+export type WhereInput<TModel extends Record<string, unknown>> = {
+	[K in keyof TModel]?: WhereFieldValue<
+		TModel[K],
+		Extract<keyof TModel, string>
+	>;
+} & {
+	geoWithin?: GeoWithinOperandForField<Extract<keyof TModel, string>>;
+	$geoWithin?: GeoWithinOperandForField<Extract<keyof TModel, string>>;
+};
+
+type ColumnData<TColumn> = TColumn extends { _: { data: infer TData } }
+	? TData
+	: unknown;
+
+type InferRelationWhereFields<TConfig> = TConfig extends { where?: infer TWhere }
+	? TWhere extends (...args: infer TArgs) => unknown
+		? TArgs extends [infer TFields, ...unknown[]]
+			? TFields extends Record<string, unknown>
+				? TFields
+				: never
+			: never
+		: never
+	: never;
+
+type RelationModelFromConfig<TConfig extends Record<string, unknown>> =
+	InferRelationWhereFields<TConfig> extends infer TFields
+		? TFields extends Record<string, unknown>
+			? {
+					[K in Extract<keyof TFields, string>]: ColumnData<TFields[K]>;
+			  }
+			: Record<string, unknown>
+		: Record<string, unknown>;
+
+type NumericModelFieldKey<TModel extends Record<string, unknown>> = Extract<
+	{
+		[K in keyof TModel]-?: NonNullable<TModel[K]> extends number ? K : never;
+	}[keyof TModel],
+	string
+>;
+
+type RelationAvgSelectionInput<TModel extends Record<string, unknown>> =
+	Partial<Record<NumericModelFieldKey<TModel>, boolean>>;
+
+type RelationAggregateSelectionInput<TModel extends Record<string, unknown>> = {
+	_count?: boolean;
+	_avg?: RelationAvgSelectionInput<TModel>;
+};
+
+type QueryWithRelationInput<TEntry> =
+	| (Extract<TEntry, true> extends never ? never : true)
+	| (Extract<TEntry, Record<string, unknown>> extends infer TRelation
+			? TRelation extends Record<string, unknown>
+				? Omit<TRelation, "where" | "with" | "_count" | "_avg"> &
+						RelationAggregateSelectionInput<RelationModelFromConfig<TRelation>> & {
+						where?: WhereInput<RelationModelFromConfig<TRelation>>;
+						with?: TRelation extends { with?: infer TNestedWith }
+							? QueryWithInput<TNestedWith>
+							: never;
+				  }
+				: never
+			: never);
+
+type QueryWithInput<TWith> = TWith extends Record<string, unknown>
+	? {
+			[K in keyof TWith]?: QueryWithRelationInput<TWith[K]>;
+	  }
+	: TWith;
+
+export type QueryFindManyArgs<TName extends TableName> = Omit<
+	NonNullable<TableFindManyArgs<TName>>,
+	"where" | "with"
+> & {
+	where?: WhereInput<TableModel<TName>>;
+	with?: QueryWithInput<NativeFindManyWith<TName>>;
+};
+
+export type QueryFindFirstArgs<TName extends TableName> = Omit<
+	NonNullable<TableFindFirstArgs<TName>>,
+	"where" | "with"
+> & {
+	where?: WhereInput<TableModel<TName>>;
+	with?: QueryWithInput<NativeFindFirstWith<TName>>;
+};
+
+export type QueryInsertArgs<TName extends TableName> = {
+	values: TableInsertModel<TName> | Array<TableInsertModel<TName>>;
+};
+
+export type QueryUpdateArgs<TName extends TableName> = {
+	set: Partial<TableInsertModel<TName>>;
+	where?: WhereInput<TableModel<TName>>;
+	limit?: number;
+};
+
+export type QueryDeleteArgs<TName extends TableName> = {
+	where?: WhereInput<TableModel<TName>>;
+	limit?: number;
+};
+`;
+}

package/cli/templates/handlers/generators/types/query-definitions/query-api-types.ts

@@ -0,0 +1,133 @@
+export function generateQueryApiTypesSection(): string {
+	return `type AggregateWithInput<TName extends TableName> =
+	QueryWithInput<NativeFindManyWith<TName>>;
+
+type NumericFieldKey<TName extends TableName> = NumericModelFieldKey<
+	TableModel<TName>
+>;
+
+type RelationAggregateAvgResult<TAvg> = TAvg extends Record<string, unknown>
+	? {
+			[K in Extract<keyof TAvg, string> as TAvg[K] extends true ? K : never]: number;
+	  }
+	: {};
+
+type RelationAggregateResult<TEntry> =
+	Extract<TEntry, Record<string, unknown>> extends infer TRelation
+		? TRelation extends Record<string, unknown>
+			? (TRelation extends { _count?: true } ? { count: number } : {}) &
+					(TRelation extends { _avg?: infer TAvg }
+						? { avg: RelationAggregateAvgResult<TAvg> }
+						: {})
+			: {}
+		: {};
+
+type HasRelationAggregateRequest<TEntry> =
+	Extract<TEntry, Record<string, unknown>> extends infer TRelation
+		? TRelation extends Record<string, unknown>
+			? TRelation extends { _count?: true }
+				? true
+				: TRelation extends { _avg?: Record<string, unknown> }
+					? true
+					: false
+			: false
+		: false;
+
+type QueryWithAggregateResult<TWith> = TWith extends Record<string, unknown>
+	? {
+			[K in Extract<keyof TWith, string> as HasRelationAggregateRequest<
+				TWith[K]
+			> extends true
+				? \`\${K}Aggregate\`
+				: never]: RelationAggregateResult<TWith[K]>;
+	  }
+	: {};
+
+type WithFromArgs<TArgs> = TArgs extends { with?: infer TWith }
+	? TWith
+	: undefined;
+
+type AppendRelationAggregatesToRow<TRow, TWith> = TRow &
+	QueryWithAggregateResult<TWith>;
+
+type ApplyFindManyWithAggregateResult<TResult, TArgs> =
+	TResult extends Promise<infer TRows>
+		? TRows extends Array<infer TRow>
+			? Promise<
+					Array<AppendRelationAggregatesToRow<TRow, WithFromArgs<TArgs>>>
+			  >
+			: TResult
+		: TResult;
+
+type ApplyFindFirstWithAggregateResult<TResult, TArgs> =
+	TResult extends Promise<infer TRow>
+		? Promise<
+				TRow extends null
+					? null
+					: AppendRelationAggregatesToRow<TRow, WithFromArgs<TArgs>>
+		  >
+		: TResult;
+
+export type QueryCountArgs<TName extends TableName> = {
+	where?: WhereInput<TableModel<TName>>;
+	field?: Extract<keyof TableModel<TName>, string> | string;
+	distinct?: boolean;
+	with?: AggregateWithInput<TName>;
+};
+
+export type QueryAvgArgs<TName extends TableName> = {
+	where?: WhereInput<TableModel<TName>>;
+	field: NumericFieldKey<TName> | string;
+	distinct?: boolean;
+	with?: AggregateWithInput<TName>;
+};
+
+export type QueryUpsertArgs<TName extends TableName> = {
+	values: TableInsertModel<TName> | Array<TableInsertModel<TName>>;
+	target?:
+		| Extract<keyof TableInsertModel<TName>, string>
+		| Array<Extract<keyof TableInsertModel<TName>, string>>;
+	set?: Partial<TableInsertModel<TName>>;
+};
+
+export type QueryTableApi<TName extends TableName> = {
+	findMany: <
+		TArgs extends QueryFindManyArgs<TName> | undefined =
+			| QueryFindManyArgs<TName>
+			| undefined,
+	>(
+		args?: TArgs,
+	) => ApplyFindManyWithAggregateResult<TableFindManyResult<TName, TArgs>, TArgs>;
+	findFirst: <
+		TArgs extends QueryFindFirstArgs<TName> | undefined =
+			| QueryFindFirstArgs<TName>
+			| undefined,
+	>(
+		args?: TArgs,
+	) => ApplyFindFirstWithAggregateResult<TableFindFirstResult<TName, TArgs>, TArgs>;
+	insert: (args: QueryInsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	update: (args: QueryUpdateArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	upsert: (args: QueryUpsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	delete: (args?: QueryDeleteArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	count: (args?: QueryCountArgs<TName>) => Promise<number>;
+	avg: (args: QueryAvgArgs<TName>) => Promise<number | null>;
+};
+
+export type AppflareQueryDb = {
+	[TName in TableName]: QueryTableApi<TName>;
+};
+
+export type DbMutationKind = "insert" | "update" | "upsert" | "delete";
+
+export type DbMutationEvent = {
+	kind: DbMutationKind;
+	table: string;
+	args: Record<string, unknown>;
+	rows: unknown[];
+};
+
+export type QueryDbOptions = {
+	onMutation?: (event: DbMutationEvent) => void;
+};
+`;
+}