appflare 0.2.40 → 0.2.42

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

@@ -561,6 +561,8 @@ export function generateQueryRuntimeWriteSection(): string {
 					return rows;
 				},
 				update: async (args: QueryUpdateArgs<TableName>) => {
+					const transaction = ($db as any).transaction;
+
 					const whereFilter = buildWhereFilter(
 						table,
 						args.where as Record<string, unknown> | undefined,
@@ -569,27 +571,286 @@ export function generateQueryRuntimeWriteSection(): string {
 
 					const setPayload = args.set as Record<string, unknown>;
 					const cleanSetPayload: Record<string, unknown> = {};
+					const relationPayloads: Array<{
+						relationName: string;
+						relation: RuntimeRelation;
+						value: unknown;
+					}> = [];
+
 					for (const [key, value] of Object.entries(setPayload)) {
-						if (value !== undefined) {
-							cleanSetPayload[key] = value;
+						if (value === undefined) continue;
+						const runtimeRelation = getRuntimeRelation(tableName, key);
+						if (runtimeRelation && runtimeRelation.kind === "manyToMany") {
+							relationPayloads.push({
+								relationName: key,
+								relation: runtimeRelation,
+								value,
+							});
+							continue;
 						}
+						cleanSetPayload[key] = value;
 					}
 
-					let updateQuery: any = ($db as any)
-						.update(table as any)
-						.set(cleanSetPayload as any);
+					const normalizeRelationValue = (
+						value: unknown,
+					): { items: unknown[]; mode: "merge" | "overwrite" } => {
+						if (Array.isArray(value)) {
+							return { items: value, mode: "merge" };
+						}
+						if (value && typeof value === "object") {
+							const record = value as Record<string, unknown>;
+							const items = Array.isArray(record.items) ? record.items : [];
+							const mode = record.mode === "overwrite" ? "overwrite" : "merge";
+							return { items, mode };
+						}
+						return { items: [], mode: "merge" };
+					};
+
+					const executeUpdateWithRelations = async (
+						tx: any,
+					): Promise<Array<TableModel<TableName>>> => {
+						let updateQuery: any = tx
+							.update(table as any)
+							.set(cleanSetPayload as any);
 
-					if (whereFilter) {
-						updateQuery = updateQuery.where(whereFilter);
-					}
-					if (typeof args.limit === "number" && typeof updateQuery.limit === "function") {
-						updateQuery = updateQuery.limit(args.limit);
-					}
-					if (typeof updateQuery.returning === "function") {
-						updateQuery = updateQuery.returning();
+						if (whereFilter) {
+							updateQuery = updateQuery.where(whereFilter);
+						}
+						if (
+							typeof args.limit === "number" &&
+							typeof updateQuery.limit === "function"
+						) {
+							updateQuery = updateQuery.limit(args.limit);
+						}
+						if (typeof updateQuery.returning === "function") {
+							updateQuery = updateQuery.returning();
+						}
+
+						const rows = (await updateQuery) as Array<TableModel<TableName>>;
+						if (rows.length === 0) return rows;
+
+						for (const row of rows) {
+							const parentId = (row as Record<string, unknown>)["id"];
+							if (parentId === undefined || parentId === null) continue;
+
+							for (const { relationName, relation, value } of relationPayloads) {
+								const { items, mode } = normalizeRelationValue(value);
+
+								const junctionTable = (mergedSchema as Record<string, unknown>)[
+									relation.junctionTable
+								];
+								if (!junctionTable) {
+									throw new Error(
+										"Unknown junction table '" +
+											relation.junctionTable +
+											"' for relation '" +
+											tableName +
+											"." +
+											relationName +
+											"'.",
+									);
+								}
+
+								const sourceField = relation.sourceField;
+								const targetField = relation.targetField;
+								if (!sourceField || !targetField) {
+									throw new Error(
+										"Relation '" +
+											tableName +
+											"." +
+											relationName +
+											"' is missing junction metadata fields.",
+									);
+								}
+
+								const parentReferenceField = relation.referenceField ?? "id";
+								const parentReferenceColumn = (table as Record<string, unknown>)[parentReferenceField];
+								if (!parentReferenceColumn) {
+									throw new Error(
+										"Table '" +
+											tableName +
+											"' is missing column '" +
+											parentReferenceField +
+											"' for relation '" +
+											relationName +
+											"'.",
+									);
+								}
+
+								const junctionSourceColumn = (junctionTable as Record<string, unknown>)[sourceField];
+								if (!junctionSourceColumn) {
+									throw new Error(
+										"Junction table '" +
+											relation.junctionTable +
+											"' is missing column '" +
+											sourceField +
+											"' for relation '" +
+											relationName +
+											"'.",
+									);
+								}
+
+								if (mode === "overwrite") {
+									await tx
+										.delete(junctionTable as any)
+										.where(eq(junctionSourceColumn as any, (row as Record<string, unknown>)[parentReferenceField] as any));
+								}
+
+								const referenceField = relation.targetReferenceField ?? "id";
+								const targetTable = (mergedSchema as Record<string, unknown>)[
+									relation.targetTable
+								];
+
+								const junctionTargetColumn =
+									(junctionTable as Record<string, unknown>)[targetField];
+								if (!junctionTargetColumn) {
+									throw new Error(
+										"Junction table '" +
+											relation.junctionTable +
+											"' is missing column '" +
+											targetField +
+											"'.",
+									);
+								}
+
+								for (const item of items) {
+									let targetId: unknown;
+
+									if (
+										typeof item === "string" ||
+										typeof item === "number" ||
+										typeof item === "bigint"
+									) {
+										targetId = item;
+									} else if (item && typeof item === "object") {
+										const record = item as Record<string, unknown>;
+										const existingId = record[referenceField];
+										if (existingId !== undefined && existingId !== null) {
+											targetId = existingId;
+										} else {
+											if (!targetTable) {
+												throw new Error(
+													"Unknown target table '" +
+														relation.targetTable +
+														"' for relation '" +
+														tableName +
+														"." +
+														relationName +
+														"'.",
+												);
+											}
+											let createQuery: any = tx
+												.insert(targetTable as any)
+												.values(record as any);
+											if (typeof createQuery.returning === "function") {
+												createQuery = createQuery.returning();
+											}
+											const createdRows =
+												(await createQuery) as Array<Record<string, unknown>>;
+											const created = createdRows[0];
+											if (!created) {
+												throw new Error(
+													"Failed to create relation target for '" +
+														tableName +
+														"." +
+														relationName +
+														"'.",
+												);
+											}
+											targetId = created[referenceField];
+											if (targetId === undefined || targetId === null) {
+												throw new Error(
+													"Created relation target for '" +
+														tableName +
+														"." +
+														relationName +
+														"' is missing '" +
+														referenceField +
+														"'.",
+												);
+											}
+										}
+									} else {
+										throw new Error(
+											"Relation '" +
+												tableName +
+												"." +
+												relationName +
+												"' expects an id or object payload.",
+										);
+									}
+
+									if (mode === "merge") {
+										const parentRefValue = (row as Record<string, unknown>)[parentReferenceField];
+										const existingLinks = await tx
+											.select()
+											.from(junctionTable as any)
+											.where(
+												and(
+													eq(junctionSourceColumn as any, parentRefValue as any),
+													eq(junctionTargetColumn as any, targetId as any),
+												),
+											);
+										if (existingLinks.length > 0) continue;
+									}
+
+									const parentRefValue = (row as Record<string, unknown>)[parentReferenceField];
+									await tx.insert(junctionTable as any).values({
+										[sourceField]: parentRefValue,
+										[targetField]: targetId,
+									} as any);
+								}
+							}
+						}
+
+						return rows;
+					};
+
+					let rows: Array<TableModel<TableName>>;
+					if (relationPayloads.length > 0) {
+						if (typeof transaction === "function") {
+							try {
+								rows = await transaction.call($db, (tx: any) =>
+									executeUpdateWithRelations(tx),
+								);
+							} catch (error) {
+								const message =
+									error instanceof Error ? error.message : String(error);
+								const lowered = message.toLowerCase();
+								if (
+									lowered.includes("failed query: begin") ||
+									lowered.includes('near "begin"') ||
+									lowered.includes("cannot start a transaction")
+								) {
+									rows = await executeUpdateWithRelations($db as any);
+								} else {
+									throw error;
+								}
+							}
+						} else {
+							rows = await executeUpdateWithRelations($db as any);
+						}
+					} else {
+						let updateQuery: any = ($db as any)
+							.update(table as any)
+							.set(cleanSetPayload as any);
+
+						if (whereFilter) {
+							updateQuery = updateQuery.where(whereFilter);
+						}
+						if (
+							typeof args.limit === "number" &&
+							typeof updateQuery.limit === "function"
+						) {
+							updateQuery = updateQuery.limit(args.limit);
+						}
+						if (typeof updateQuery.returning === "function") {
+							updateQuery = updateQuery.returning();
+						}
+
+						rows = (await updateQuery) as Array<TableModel<TableName>>;
 					}
 
-					const rows = (await updateQuery) as Array<TableModel<TableName>>;
 					emitMutation(
 						"update",
 						{