appflare 0.2.16 → 0.2.17

package/cli/templates/dashboard/builders/table-routes/fragments.ts

@@ -52,12 +52,15 @@ export function buildColumnHeaders(
 		.join("");
 }
 
-export function buildRowCells(columns: string[]): string {
+export function buildRowCells(columns: string[], primaryKey?: string): string {
 	return columns
-		.map(
-			(column) =>
-				`<td><div class="truncate max-w-[200px] text-sm" title="\${String((row as any).${column} ?? '')}">\${String((row as any).${column} ?? '')}</div></td>`,
-		)
+		.map((column) => {
+			if (primaryKey && column === primaryKey) {
+				return `<td><button type="button" class="truncate max-w-[200px] text-sm font-mono text-xs opacity-70 hover:opacity-100 cursor-copy text-left" title="Click to copy: \${String((row as any).${column} ?? '')}" data-copy-value="\${String((row as any).${column} ?? '')}" onclick="navigator.clipboard?.writeText(this.dataset.copyValue || '')">\${String((row as any).${column} ?? '')}</button></td>`;
+			}
+
+			return `<td><div class="truncate max-w-[200px] text-sm" title="\${String((row as any).${column} ?? '')}">\${String((row as any).${column} ?? '')}</div></td>`;
+		})
 		.join("");
 }
 

package/cli/templates/dashboard/builders/table-routes/table/index.ts

@@ -31,7 +31,7 @@ export function buildTableRoute(table: DiscoveredTable): string {
 	);
 	const searchConditions = buildSearchConditions(table);
 	const headers = buildColumnHeaders(table, columns);
-	const rowCells = buildRowCells(columns);
+	const rowCells = buildRowCells(columns, primaryKey);
 	const createInputs = createColumns
 		.map((columnName) => buildFieldInput(table, columnName, "create"))
 		.join("");

package/cli/templates/dashboard/builders/table-routes/users/html/table.ts

@@ -55,7 +55,7 @@ export function buildUsersTableHtml(): string {
 \t\t\t\t\t\t<tbody>
 \t\t\t\t\t\t\t\${data.map((row) => html\`
 \t\t\t\t\t\t\t\t<tr class="hover:bg-base-200/30 transition-colors">
-\t\t\t\t\t\t\t\t\t<td><div class="truncate max-w-[220px] text-sm font-mono text-xs opacity-60" title="\${String((row as any).id ?? '')}">\${String((row as any).id ?? '')}</div></td>
+\t\t\t\t\t\t\t\t\t<td><button type="button" class="truncate max-w-[220px] text-sm font-mono text-xs opacity-70 hover:opacity-100 cursor-copy text-left" title="Click to copy: \${String((row as any).id ?? '')}" data-copy-value="\${String((row as any).id ?? '')}" onclick="navigator.clipboard?.writeText(this.dataset.copyValue || '')">\${String((row as any).id ?? '')}</button></td>
 \t\t\t\t\t\t\t\t\t<td><div class="truncate max-w-[220px] text-sm" title="\${String((row as any).name ?? '')}">\${String((row as any).name ?? '')}</div></td>
 \t\t\t\t\t\t\t\t\t<td><div class="truncate max-w-[260px] text-sm" title="\${String((row as any).email ?? '')}">\${String((row as any).email ?? '')}</div></td>
 \t\t\t\t\t\t\t\t\t<td><span class="badge badge-sm \${String((row as any).role ?? '') === 'admin' ? 'badge-primary' : 'badge-ghost'}">\${String((row as any).role ?? '')}</span></td>
@@ -123,5 +123,6 @@ ${buildDeleteUserModal()}
 \t\t\t\t</div>
 \t\t\t\t${paginationHtml}
 \t\t\t</div>
-\t\t\`;`;
+\t\t\`;
+`;
 }

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

@@ -143,11 +143,11 @@ type QueryWithRelationInputForTable<
 	TSourceTable extends TableName,
 	TRelationName extends string,
 	TEntry,
-> = ManyToManyTargetTableName<TSourceTable, TRelationName> extends infer TTarget
-	? TTarget extends TableName
-		? QueryManyToManyWithRelationInput<TTarget>
-		: QueryNativeWithRelationInput<TEntry>
-	: QueryNativeWithRelationInput<TEntry>;
+> = [ManyToManyTargetTableName<TSourceTable, TRelationName>] extends [never]
+	? QueryNativeWithRelationInput<TEntry>
+	: QueryManyToManyWithRelationInput<
+			Extract<ManyToManyTargetTableName<TSourceTable, TRelationName>, TableName>
+	  >;
 
 type QueryWithInputForTable<
 	TSourceTable extends TableName,
@@ -183,13 +183,6 @@ export type QueryFindFirstArgs<TName extends TableName> = Omit<
 	with?: QueryWithInput<TName, NativeFindFirstWith<TName>>;
 };
 
-type SingularizeRelationName<TName extends string> =
-	TName extends \`\${infer TRoot\}ies\`
-		? \`\${TRoot\}y\`
-		: TName extends \`\${infer TRoot\}s\`
-			? TRoot
-			: TName;
-
 type RelationInsertItem<TTargetTable extends TableName> =
 	| TableModel<TTargetTable>
 	| TableInsertModel<TTargetTable>
@@ -215,21 +208,38 @@ type RelationInsertFields<TName extends TableName> = {
 	>;
 };
 
-type RelationInsertIdAliasFields<TName extends TableName> = {
-	[TRelationName in RuntimeRelationName<TName> as \`\${TRelationName\}Id\`]?: RelationInsertValue<
-		TName,
-		TRelationName
-	>;
-} & {
-	[TRelationName in RuntimeRelationName<TName> as \`\${SingularizeRelationName<TRelationName>\}Id\`]?: RelationInsertValue<
-		TName,
-		TRelationName
-	>;
-};
-
 type QueryInsertValue<TName extends TableName> = TableInsertScalarModel<TName> &
-	RelationInsertFields<TName> &
-	RelationInsertIdAliasFields<TName>;
+	RelationInsertFields<TName>;
+
+type InsertItemValue<TArgs> = TArgs extends { values: infer TValue }
+	? TValue extends Array<infer TItem>
+		? TItem
+		: TValue
+	: never;
+
+type InsertRelationNameFromArgs<
+	TName extends TableName,
+	TArgs,
+> = Extract<keyof InsertItemValue<TArgs>, RuntimeRelationName<TName>>;
+
+type InsertRelationResultValue<
+	TSourceTable extends TableName,
+	TRelationName extends RuntimeRelationName<TSourceTable>,
+> = RuntimeRelationTargetTable<TSourceTable, TRelationName> extends infer TTargetTable
+	? TTargetTable extends TableName
+		? RuntimeRelationKind<TSourceTable, TRelationName> extends "one"
+			? TableModel<TTargetTable> | null
+			: Array<TableModel<TTargetTable>>
+		: never
+	: never;
+
+export type QueryInsertResultRow<
+	TName extends TableName,
+	TArgs extends QueryInsertArgs<TName>,
+> = TableModel<TName> & {
+	[TRelationName in InsertRelationNameFromArgs<TName, TArgs>]:
+		InsertRelationResultValue<TName, TRelationName>;
+};
 
 export type QueryInsertArgs<TName extends TableName> = {
 	values: QueryInsertValue<TName> | Array<QueryInsertValue<TName>>;

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

@@ -105,7 +105,9 @@ export type QueryTableApi<TName extends TableName> = {
 	>(
 		args?: TArgs,
 	) => ApplyFindFirstWithAggregateResult<TableFindFirstResult<TName, TArgs>, TArgs>;
-	insert: (args: QueryInsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	insert: <TArgs extends QueryInsertArgs<TName>>(
+		args: TArgs,
+	) => Promise<Array<QueryInsertResultRow<TName, TArgs>>>;
 	update: (args: QueryUpdateArgs<TName>) => Promise<Array<TableModel<TName>>>;
 	upsert: (args: QueryUpsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
 	delete: (args?: QueryDeleteArgs<TName>) => Promise<Array<TableModel<TName>>>;

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

@@ -48,45 +48,44 @@ type TableModel<TName extends TableName> = InferSelectModel<
 	(typeof mergedSchema)[TName]
 >;
 type ManyToManySchemaMap = typeof schema extends {
-	__appflareManyToMany: infer TMap;
+	__appflareManyToMany: infer TMap extends Record<string, unknown>;
 }
-	? TMap extends Record<string, Record<string, { targetTable: string }>>
-		? TMap
-		: {}
+	? TMap
 	: {};
+type ManyToManySourceTableMap<TSourceTable extends TableName> =
+	TSourceTable extends keyof ManyToManySchemaMap
+		? ManyToManySchemaMap[TSourceTable] extends Record<string, unknown>
+			? ManyToManySchemaMap[TSourceTable]
+			: {}
+		: {};
 type ManyToManyTargetTableName<
 	TSourceTable extends TableName,
 	TRelationName extends string,
-> = TSourceTable extends keyof ManyToManySchemaMap
-	? TRelationName extends keyof ManyToManySchemaMap[TSourceTable]
-		? ManyToManySchemaMap[TSourceTable][TRelationName] extends {
+> = TRelationName extends keyof ManyToManySourceTableMap<TSourceTable>
+	? ManyToManySourceTableMap<TSourceTable>[TRelationName] extends {
 				targetTable: infer TTarget extends string;
 		  }
 			? Extract<TTarget, TableName>
 			: never
-		: never
 	: never;
 type RuntimeRelationsSchemaMap = typeof schema extends {
-	__appflareRelations: infer TMap;
+	__appflareRelations: infer TMap extends Record<string, unknown>;
 }
-	? TMap extends Record<
-			string,
-			Record<string, { kind: string; targetTable: string }>
-	  >
-		? TMap
-		: {}
+	? TMap
 	: {};
-type RuntimeRelationName<TSourceTable extends TableName> =
+type RuntimeRelationsSourceTableMap<TSourceTable extends TableName> =
 	TSourceTable extends keyof RuntimeRelationsSchemaMap
-		? Extract<keyof RuntimeRelationsSchemaMap[TSourceTable], string>
-		: never;
+		? RuntimeRelationsSchemaMap[TSourceTable] extends Record<string, unknown>
+			? RuntimeRelationsSchemaMap[TSourceTable]
+			: {}
+		: {};
+type RuntimeRelationName<TSourceTable extends TableName> =
+	Extract<keyof RuntimeRelationsSourceTableMap<TSourceTable>, string>;
 type RuntimeRelationConfig<
 	TSourceTable extends TableName,
 	TRelationName extends string,
-> = TSourceTable extends keyof RuntimeRelationsSchemaMap
-	? TRelationName extends keyof RuntimeRelationsSchemaMap[TSourceTable]
-		? RuntimeRelationsSchemaMap[TSourceTable][TRelationName]
-		: never
+> = TRelationName extends keyof RuntimeRelationsSourceTableMap<TSourceTable>
+	? RuntimeRelationsSourceTableMap<TSourceTable>[TRelationName]
 	: never;
 type RuntimeRelationKind<
 	TSourceTable extends TableName,
@@ -104,10 +103,7 @@ type RuntimeRelationTargetTable<
 }
 	? Extract<TTarget, TableName>
 	: never;
-type TableInsertScalarModel<TName extends TableName> = Omit<
-	TableInsertModel<TName>,
-	RuntimeRelationName<TName>
->;
+type TableInsertScalarModel<TName extends TableName> = TableInsertModel<TName>;
 type FindManyWithFromArgs<TArgs> = TArgs extends { with?: infer TWith }
 	? TWith
 	: undefined;
@@ -136,11 +132,12 @@ type ReplaceManyToManyRelationsInRow<
 			[K in keyof TRow]: K extends string
 				? TWith extends Record<string, unknown>
 					? K extends keyof TWith
-						? ManyToManyTargetTableName<TSourceTable, K> extends infer TTarget
-							? TTarget extends TableName
-								? ManyToManyRelationRows<TTarget, TWith[K]>
-								: TRow[K]
-							: TRow[K]
+						? [ManyToManyTargetTableName<TSourceTable, K>] extends [never]
+							? TRow[K]
+							: ManyToManyRelationRows<
+									Extract<ManyToManyTargetTableName<TSourceTable, K>, TableName>,
+									TWith[K]
+							  >
 						: TRow[K]
 					: TRow[K]
 				: TRow[K];
@@ -202,10 +199,7 @@ type TableFindFirstArgs<TName extends TableName> = Omit<
 	TableFindManyArgs<TName>,
 	"limit"
 >;
-type NativeFindFirstWith<TName extends TableName> =
-	NonNullable<TableFindFirstArgs<TName>> extends { with?: infer TWith }
-		? TWith
-		: never;
+type NativeFindFirstWith<TName extends TableName> = NativeFindManyWith<TName>;
 type ResolveNativeFindFirstWith<
 	TName extends TableName,
 	TArgs extends QueryFindFirstArgs<TName> | undefined,

package/cli/templates/handlers/generators/types/query-runtime/runtime-write.ts

@@ -1,5 +1,5 @@
 export function generateQueryRuntimeWriteSection(): string {
-	return `				insert: async (args: QueryInsertArgs<TableName>) => {
+	return `				insert: async <TArgs extends QueryInsertArgs<TableName>>(args: TArgs) => {
 					const transaction = ($db as any).transaction;
 
 					const valuesArray = Array.isArray(args.values)
@@ -14,16 +14,6 @@ export function generateQueryRuntimeWriteSection(): string {
 						}>
 					> = [];
 
-					const resolveSingularAlias = (relationName: string): string => {
-						if (relationName.endsWith("ies")) {
-							return relationName.slice(0, -3) + "yId";
-						}
-						if (relationName.endsWith("s") && relationName.length > 1) {
-							return relationName.slice(0, -1) + "Id";
-						}
-						return relationName + "Id";
-					};
-
 					const toRelationItems = (
 						relation: RuntimeRelation,
 						relationName: string,
@@ -76,7 +66,7 @@ export function generateQueryRuntimeWriteSection(): string {
 						const referenceField =
 							relation.kind === "manyToMany"
 								? (relation.targetReferenceField ?? "id")
-								: "id";
+								: (relation.referenceField ?? "id");
 						const existingId = input[referenceField];
 						if (existingId !== undefined && existingId !== null) {
 							return existingId;
@@ -129,6 +119,74 @@ export function generateQueryRuntimeWriteSection(): string {
 						return createdId;
 					};
 
+					const getRelationTargetTable = (
+						relation: RuntimeRelation,
+						relationName: string,
+					): any => {
+						const targetTable = (mergedSchema as Record<string, unknown>)[
+							relation.targetTable
+						];
+						if (!targetTable) {
+							throw new Error(
+								"Unknown target table '" +
+									relation.targetTable +
+									"' for relation '" +
+									tableName +
+									"." +
+									relationName +
+									"'.",
+							);
+						}
+						return targetTable;
+					};
+
+					const getRelationReferenceField = (relation: RuntimeRelation): string => {
+						if (relation.kind === "manyToMany") {
+							return relation.targetReferenceField ?? "id";
+						}
+						return relation.referenceField ?? "id";
+					};
+
+					const fetchRelatedRowByIdentifier = async (
+						tx: any,
+						relation: RuntimeRelation,
+						relationName: string,
+						identifier: unknown,
+					): Promise<Record<string, unknown> | null> => {
+						if (identifier === undefined || identifier === null) {
+							return null;
+						}
+
+						const targetTable = getRelationTargetTable(relation, relationName);
+						const referenceField = getRelationReferenceField(relation);
+						const referenceColumn = (targetTable as Record<string, unknown>)[
+							referenceField
+						];
+						if (!referenceColumn) {
+							throw new Error(
+								"Target table '" +
+									relation.targetTable +
+									"' is missing column '" +
+									referenceField +
+									"' required by relation '" +
+									tableName +
+									"." +
+									relationName +
+									"'.",
+							);
+						}
+
+						let query: any = tx
+							.select()
+							.from(targetTable as any)
+							.where(eq(referenceColumn as any, identifier as any));
+						if (typeof query.limit === "function") {
+							query = query.limit(1);
+						}
+						const rows = (await query) as Array<Record<string, unknown>>;
+						return rows[0] ?? null;
+					};
+
 					for (const inputValue of valuesArray) {
 						const scalarValues: Record<string, unknown> = {};
 						const relationInputs: Array<{
@@ -148,50 +206,16 @@ export function generateQueryRuntimeWriteSection(): string {
 								});
 								continue;
 							}
-
-							let matchedAlias = false;
-							if (fieldName.endsWith("Id")) {
-								for (const [relationName, relationValue] of Object.entries(
-									runtimeRelationMap[tableName] ?? {},
-								)) {
-									const pluralAlias = relationName + "Id";
-									const singularAlias = resolveSingularAlias(relationName);
-									if (fieldName !== pluralAlias && fieldName !== singularAlias) {
-										continue;
-									}
-
-									if (valueRecord[relationName] !== undefined) {
-										throw new Error(
-											"Insert payload for '" +
-												tableName +
-												"' cannot contain both '" +
-												relationName +
-												"' and '" +
-												fieldName +
-												"'.",
-										);
-									}
-
-									relationInputs.push({
-										relationName,
-										relation: relationValue,
-										value: fieldValue,
-									});
-									matchedAlias = true;
-									break;
-								}
-							}
-
-							if (!matchedAlias) {
-								scalarValues[fieldName] = fieldValue;
-							}
+							scalarValues[fieldName] = fieldValue;
 						}
 
 						baseValuesArray.push(scalarValues);
 						postInsertRelations.push(relationInputs);
 					}
 
-					const executeInsertGraph = async (tx: any): Promise<Array<TableModel<TableName>>> => {
+					const executeInsertGraph = async (
+						tx: any,
+					): Promise<Array<QueryInsertResultRow<TableName, TArgs>>> => {
 						for (let index = 0; index < baseValuesArray.length; index += 1) {
 							const relationInputs = postInsertRelations[index] ?? [];
 							for (const relationInput of relationInputs) {
@@ -247,13 +271,46 @@ export function generateQueryRuntimeWriteSection(): string {
 							insertQuery = insertQuery.returning();
 						}
 						const insertedRows = (await insertQuery) as Array<TableModel<TableName>>;
+						const hydratedRows: Array<Record<string, unknown>> = [];
 
 						for (let index = 0; index < insertedRows.length; index += 1) {
 							const parentRow = insertedRows[index] as unknown as Record<string, unknown>;
+							const hydratedRow: Record<string, unknown> = {
+								...parentRow,
+							};
 							const relationInputs = postInsertRelations[index] ?? [];
 
 							for (const relationInput of relationInputs) {
 								if (relationInput.relation.kind === "one") {
+									const sourceField = relationInput.relation.sourceField;
+									if (!sourceField) {
+										throw new Error(
+											"Relation '" +
+												tableName +
+												"." +
+												relationInput.relationName +
+												"' is missing sourceField metadata.",
+										);
+									}
+
+									const relationItems = toRelationItems(
+										relationInput.relation,
+										relationInput.relationName,
+										relationInput.value,
+									);
+									if (relationItems.length === 0) {
+										hydratedRow[relationInput.relationName] = null;
+										continue;
+									}
+
+									const sourceIdentifier = parentRow[sourceField];
+									hydratedRow[relationInput.relationName] =
+										(await fetchRelatedRowByIdentifier(
+											tx,
+											relationInput.relation,
+											relationInput.relationName,
+											sourceIdentifier,
+										)) ?? null;
 									continue;
 								}
 
@@ -274,6 +331,9 @@ export function generateQueryRuntimeWriteSection(): string {
 									);
 								}
 
+								const relatedRows: Array<Record<string, unknown>> = [];
+								hydratedRow[relationInput.relationName] = relatedRows;
+
 								const relationItems = toRelationItems(
 									relationInput.relation,
 									relationInput.relationName,
@@ -284,29 +344,36 @@ export function generateQueryRuntimeWriteSection(): string {
 								}
 
 								if (relationInput.relation.kind === "many") {
-									const targetTable = (mergedSchema as Record<string, unknown>)[
-										relationInput.relation.targetTable
-									];
-									if (!targetTable) {
+									const targetTable = getRelationTargetTable(
+										relationInput.relation,
+										relationInput.relationName,
+									);
+
+									const sourceField = relationInput.relation.sourceField;
+									const targetReferenceField =
+										relationInput.relation.referenceField ?? "id";
+									const targetReferenceColumn =
+										(targetTable as Record<string, unknown>)[targetReferenceField];
+									if (!sourceField) {
 										throw new Error(
-											"Unknown target table '" +
-												relationInput.relation.targetTable +
-												"' for relation '" +
+											"Relation '" +
 												tableName +
 												"." +
 												relationInput.relationName +
-												"'.",
+												"' is missing sourceField metadata.",
 										);
 									}
-
-									const sourceField = relationInput.relation.sourceField;
-									if (!sourceField) {
+									if (!targetReferenceColumn) {
 										throw new Error(
-											"Relation '" +
+											"Target table '" +
+												relationInput.relation.targetTable +
+												"' is missing column '" +
+												targetReferenceField +
+												"' required by relation '" +
 												tableName +
 												"." +
 												relationInput.relationName +
-												"' is missing sourceField metadata.",
+												"'.",
 										);
 									}
 
@@ -319,7 +386,18 @@ export function generateQueryRuntimeWriteSection(): string {
 											await tx
 												.update(targetTable as any)
 												.set({ [sourceField]: parentReferenceValue } as any)
-												.where(eq((targetTable as any).id, relationItem as any));
+												.where(
+													eq(targetReferenceColumn as any, relationItem as any),
+												);
+											const linkedRow = await fetchRelatedRowByIdentifier(
+												tx,
+												relationInput.relation,
+												relationInput.relationName,
+												relationItem,
+											);
+											if (linkedRow) {
+												relatedRows.push(linkedRow);
+											}
 											continue;
 										}
 
@@ -333,22 +411,48 @@ export function generateQueryRuntimeWriteSection(): string {
 											);
 										}
 
-										const existingId = relationItem.id;
+										const existingId = relationItem[targetReferenceField];
 										const payload = {
 											...relationItem,
 											[sourceField]: parentReferenceValue,
 										};
 
 										if (existingId !== undefined && existingId !== null) {
-											const { id: _ignored, ...setPayload } = payload;
+											const setPayload: Record<string, unknown> = {
+												...payload,
+											};
+											delete setPayload[targetReferenceField];
 											await tx
 												.update(targetTable as any)
 												.set(setPayload as any)
-												.where(eq((targetTable as any).id, existingId as any));
+												.where(
+													eq(targetReferenceColumn as any, existingId as any),
+												);
+											const linkedRow = await fetchRelatedRowByIdentifier(
+												tx,
+												relationInput.relation,
+												relationInput.relationName,
+												existingId,
+											);
+											if (linkedRow) {
+												relatedRows.push(linkedRow);
+											}
 											continue;
 										}
 
-										await tx.insert(targetTable as any).values(payload as any);
+										let createQuery: any = tx
+											.insert(targetTable as any)
+											.values(payload as any);
+										if (typeof createQuery.returning === "function") {
+											createQuery = createQuery.returning();
+										}
+										const createdRows = (await createQuery) as Array<
+											Record<string, unknown>
+										>;
+										const createdRow = createdRows[0];
+										if (createdRow) {
+											relatedRows.push(createdRow);
+										}
 									}
 									continue;
 								}
@@ -381,6 +485,7 @@ export function generateQueryRuntimeWriteSection(): string {
 								}
 
 								const linkValues: Array<Record<string, unknown>> = [];
+								const targetIdentifiers: unknown[] = [];
 								for (const relationItem of relationItems) {
 									const targetId = await resolveRelationIdentifier(
 										tx,
@@ -388,6 +493,7 @@ export function generateQueryRuntimeWriteSection(): string {
 										relationInput.relationName,
 										relationItem,
 									);
+									targetIdentifiers.push(targetId);
 
 									linkValues.push({
 										[sourceField]: parentReferenceValue,
@@ -398,13 +504,27 @@ export function generateQueryRuntimeWriteSection(): string {
 								if (linkValues.length > 0) {
 									await tx.insert(junctionTable as any).values(linkValues as any);
 								}
+
+								for (const targetId of targetIdentifiers) {
+									const linkedRow = await fetchRelatedRowByIdentifier(
+										tx,
+										relationInput.relation,
+										relationInput.relationName,
+										targetId,
+									);
+									if (linkedRow) {
+										relatedRows.push(linkedRow);
+									}
+								}
 							}
+
+							hydratedRows.push(hydratedRow);
 						}
 
-						return insertedRows;
+						return hydratedRows as Array<QueryInsertResultRow<TableName, TArgs>>;
 					};
 
-					let rows: Array<TableModel<TableName>>;
+					let rows: Array<QueryInsertResultRow<TableName, TArgs>>;
 					if (typeof transaction === "function") {
 						try {
 							rows = await transaction.call($db, (tx: any) =>