appflare 0.2.49 → 0.2.50

package/cli/schema-compiler.ts

@@ -965,11 +965,13 @@ function emitDrizzleSchema(
 
 	const tableBlocks: string[] = [];
 	const relationBlocks: string[] = [];
+	const dbSchemaEntries: string[] = [];
 
 	for (const [tableName, table] of Object.entries(definition.tables)) {
 		const sqlTableName = table.sqlName ?? toSnakeCase(tableName);
 		const columnLines: string[] = [];
 		const indexes: string[] = [];
+		dbSchemaEntries.push(`\t${tableName},`);
 
 		for (const [fieldName, column] of Object.entries(table.columns)) {
 			let expr: string;
@@ -1018,9 +1020,9 @@ function emitDrizzleSchema(
 					if (column.references.onUpdate) {
 						actions.push(`onUpdate: ${quote(column.references.onUpdate)}`);
 					}
-					expr += `.references(() => ${reference.tableName}.${reference.fieldName}, { ${actions.join(", ")} })`;
+					expr += `.references((): AnySQLiteColumn => ${reference.tableName}.${reference.fieldName}, { ${actions.join(", ")} })`;
 				} else {
-					expr += `.references(() => ${reference.tableName}.${reference.fieldName})`;
+					expr += `.references((): AnySQLiteColumn => ${reference.tableName}.${reference.fieldName})`;
 				}
 			}
 
@@ -1101,10 +1103,11 @@ function emitDrizzleSchema(
 		relationBlocks.push(
 			`export const ${tableName}Relations = relations(${tableName}, ({ one, many }) => ({\n${relationLines.join("\n")}\n}));`,
 		);
+		dbSchemaEntries.push(`\t${tableName}Relations,`);
 	}
 
 	return `import * as t from "drizzle-orm/sqlite-core";
-import { sqliteTable as table } from "drizzle-orm/sqlite-core";
+import { sqliteTable as table, type AnySQLiteColumn } from "drizzle-orm/sqlite-core";
 import { relations } from "drizzle-orm";
 ${buildExternalTableImportLines(externalTables)}
 ${enumTypeLines.join("\n")}
@@ -1114,6 +1117,10 @@ ${tableBlocks.join("\n\n")}
 
 ${relationBlocks.join("\n\n")}
 
+export const __appflareDbSchema = {
+${dbSchemaEntries.join("\n")}
+} as const;
+
 ${emitJsonColumnsMetadata(definition)}
 
 ${emitManyToManyRuntimeMetadata(definition)}

package/cli/templates/handlers/generators/types/query-definitions/schema-and-table-types.ts

@@ -4,12 +4,17 @@ export function generateSchemaAndTableTypesSection(): string {
 	...schema,
 };
 
+const mergedDbSchema = {
+	...authSchema,
+	...schema.__appflareDbSchema,
+};
+
 export const createDb = (database: D1Database) =>
-	drizzle(database, { schema: mergedSchema });
+	drizzle(database, { schema: mergedDbSchema });
 
 export type AppflareDb = ReturnType<typeof createDb>;
 
-type SchemaRelations = ExtractTablesWithRelations<typeof mergedSchema>;
+type SchemaRelations = ExtractTablesWithRelations<typeof mergedDbSchema>;
 type TableName = Extract<keyof SchemaRelations, string>;
 type TableRelationConfig<TName extends TableName> =
 	TName extends keyof SchemaRelations ? SchemaRelations[TName] : never;
@@ -23,29 +28,11 @@ type NativeFindManyWith<TName extends TableName> =
 	NonNullable<TableFindManyArgs<TName>> extends { with?: infer TWith }
 		? TWith
 		: never;
-type NormalizeWhereInWith<TWith, TNativeWith> = TWith extends Record<string, unknown>
-	? {
-			[K in keyof TWith]: K extends keyof TNativeWith
-				? TWith[K] extends Record<string, unknown>
-					? Omit<TWith[K], 'where'> & { where?: NonNullable<Extract<TNativeWith[K], Record<string, unknown>>['where']> } & (TWith[K] extends { with: infer TNestedWith }
-						? { with: NormalizeWhereInWith<TNestedWith, TNativeWith[K]> }
-						: {})
-					: TWith[K]
-				: TWith[K];
-		}
-	: TWith;
-
 type ResolveNativeFindManyWith<
 	TName extends TableName,
 	TArgs extends QueryFindManyArgs<TName> | undefined,
 > = TArgs extends { with?: infer TWith }
-	? Extract<TWith, NativeFindManyWith<TName>> extends infer TResolved
-		? [TResolved] extends [never]
-			? TWith extends Record<string, unknown>
-				? NormalizeWhereInWith<TWith, NativeFindManyWith<TName>>
-				: never
-			: TResolved
-		: never
+	? NormalizeNativeWithForTable<TName, TWith>
 	: never;
 type ResolveTableFindManySelection<
 	TName extends TableName,
@@ -57,7 +44,7 @@ type ResolveTableFindManySelection<
 				? {}
 				: { with: ResolveNativeFindManyWith<TName, TArgs> });
 type TableModel<TName extends TableName> = InferSelectModel<
-	(typeof mergedSchema)[TName]
+	(typeof mergedDbSchema)[TName]
 >;
 type ManyToManySchemaMap = typeof schema extends {
 	__appflareManyToMany: infer TMap extends Record<string, unknown>;
@@ -115,6 +102,148 @@ type RuntimeRelationTargetTable<
 }
 	? Extract<TTarget, TableName>
 	: never;
+type NativeRelationEntry<
+	TSourceTable extends TableName,
+	TRelationName extends string,
+> = TRelationName extends keyof NativeFindManyWith<TSourceTable>
+	? NativeFindManyWith<TSourceTable>[TRelationName]
+	: never;
+type NativeRelationWhere<TEntry> = Extract<
+	TEntry,
+	Record<string, unknown>
+> extends {
+	where?: infer TWhere;
+}
+	? TWhere
+	: never;
+type ManyToManyJunctionTableName<
+	TSourceTable extends TableName,
+	TRelationName extends string,
+> = TRelationName extends keyof ManyToManySourceTableMap<TSourceTable>
+	? ManyToManySourceTableMap<TSourceTable>[TRelationName] extends {
+				junctionTable: infer TJunctionTable extends string;
+		  }
+			? Extract<TJunctionTable, TableName>
+			: never
+	: never;
+type CleanRelationConfig<TEntry> = Omit<
+	Extract<TEntry, Record<string, unknown>>,
+	"where" | "with" | "_count" | "_avg"
+>;
+type NormalizeNativeRelationConfig<
+	TSourceTable extends TableName,
+	TRelationName extends string,
+	TEntry,
+> = CleanRelationConfig<TEntry> &
+	(Extract<TEntry, Record<string, unknown>> extends { where?: unknown }
+		? {
+				where?: NativeRelationWhere<
+					NativeRelationEntry<TSourceTable, TRelationName>
+				>;
+		  }
+		: {}) &
+	(Extract<TEntry, Record<string, unknown>> extends { with?: infer TNestedWith }
+		? RuntimeRelationTargetTable<TSourceTable, TRelationName> extends infer TTargetTable
+			? TTargetTable extends TableName
+				? {
+						with?: NormalizeNativeWithForTable<TTargetTable, TNestedWith>;
+				  }
+				: {}
+			: {}
+		: {});
+type NormalizeManyToManyTargetConfig<
+	TSourceTable extends TableName,
+	TRelationName extends string,
+	TEntry,
+> = ManyToManyTargetTableName<
+	TSourceTable,
+	TRelationName
+> extends infer TTargetTable
+	? TTargetTable extends TableName
+		? CleanRelationConfig<TEntry> &
+				(Extract<TEntry, Record<string, unknown>> extends { where?: unknown }
+					? ManyToManyJunctionTableName<
+							TSourceTable,
+							TRelationName
+					  > extends infer TJunctionTable
+						? TJunctionTable extends TableName
+							? {
+									where?: NativeRelationWhere<
+										NativeRelationEntry<TJunctionTable, TTargetTable>
+									>;
+							  }
+							: {}
+						: {}
+					: {}) &
+				(Extract<TEntry, Record<string, unknown>> extends {
+					with?: infer TNestedWith;
+				}
+					? {
+							with?: NormalizeNativeWithForTable<TTargetTable, TNestedWith>;
+					  }
+					: {})
+		: never
+	: never;
+type NormalizeRelationInputForTable<
+	TSourceTable extends TableName,
+	TRelationName extends string,
+	TEntry,
+> = [ManyToManyTargetTableName<TSourceTable, TRelationName>] extends [never]
+	? (Extract<TEntry, true> extends never ? never : true) |
+			(Extract<TEntry, Record<string, unknown>> extends infer TConfig
+				? TConfig extends Record<string, unknown>
+					? NormalizeNativeRelationConfig<
+							TSourceTable,
+							TRelationName,
+							TConfig
+					  >
+					: never
+				: never)
+	: ManyToManyTargetTableName<
+			TSourceTable,
+			TRelationName
+	  > extends infer TTargetTable
+		? TTargetTable extends TableName
+			? (Extract<TEntry, true> extends never
+					? never
+					: {
+							with: {
+								[K in TTargetTable]: true;
+							};
+					  }) |
+					(Extract<TEntry, Record<string, unknown>> extends infer TConfig
+						? TConfig extends Record<string, unknown>
+							? CleanRelationConfig<TConfig> & {
+									with: {
+										[K in TTargetTable]: keyof NormalizeManyToManyTargetConfig<
+											TSourceTable,
+											TRelationName,
+											TConfig
+										> extends never
+											? true
+											: NormalizeManyToManyTargetConfig<
+													TSourceTable,
+													TRelationName,
+													TConfig
+											  >;
+									};
+							  }
+							: never
+						: never)
+			: never
+		: never;
+type NormalizeNativeWithForTable<
+	TSourceTable extends TableName,
+	TWith,
+> = TWith extends Record<string, unknown>
+	? {
+			[K in keyof TWith]: NormalizeRelationInputForTable<
+				TSourceTable,
+				Extract<K, string>,
+				TWith[K]
+			>;
+	  }
+	: TWith;
 
 type TargetTableForRelation<
 	TSource extends TableName,
@@ -236,13 +365,7 @@ type ResolveNativeFindFirstWith<
 	TName extends TableName,
 	TArgs extends QueryFindFirstArgs<TName> | undefined,
 > = TArgs extends { with?: infer TWith }
-	? Extract<TWith, NativeFindFirstWith<TName>> extends infer TResolved
-		? [TResolved] extends [never]
-			? TWith extends Record<string, unknown>
-				? NormalizeWhereInWith<TWith, NativeFindFirstWith<TName>>
-				: never
-			: TResolved
-		: never
+	? NormalizeNativeWithForTable<TName, TWith>
 	: never;
 type ResolveTableFindFirstSelection<
 	TName extends TableName,
@@ -272,7 +395,7 @@ type TableFindFirstResult<
 		  >
 >;
 type TableInsertModel<TName extends TableName> = InferInsertModel<
-	(typeof mergedSchema)[TName]
+	(typeof mergedDbSchema)[TName]
 >;
 `;
 }