@mastra/pg 1.36.0-alpha.2 → 1.36.0-alpha.4

package/dist/index.js

@@ -250,31 +250,29 @@ function buildElemMatchConditions(value, paramIndex) {
 	if (typeof value !== "object" || Array.isArray(value)) throw new Error("$elemMatch requires an object with conditions");
 	const conditions = [];
 	const values = [];
+	function buildFieldCondition(field, operator, operatorValue) {
+		if (operator === "$not") {
+			const nested = Object.entries(operatorValue);
+			if (nested.length === 0) throw new Error("$not requires at least one operator");
+			return `NOT (COALESCE(${nested.map(([nestedOp, nestedValue]) => buildFieldCondition(field, nestedOp, nestedValue)).join(" AND ")}, FALSE))`;
+		}
+		const operatorFn = FILTER_OPERATORS[operator];
+		if (!operatorFn) throw new Error(`Invalid operator: ${operator}`);
+		const scalarElement = field.startsWith("$");
+		const result = operatorFn(scalarElement ? "" : field, paramIndex + values.length, operatorValue);
+		const sql = result.sql.replaceAll("metadata->>", "elem->>").replaceAll("metadata->", "elem->").replaceAll("metadata#>>", "elem#>>").replaceAll("metadata#>", "elem#>").replaceAll("metadata ?", "elem ?");
+		const elementSql = scalarElement ? sql.replaceAll("elem->>''", "elem #>> '{}'").replaceAll("elem->''", "elem") : sql;
+		if (result.needsValue) {
+			const transformedValue = result.transformValue ? result.transformValue() : operatorValue;
+			if (operator === "$elemMatch") values.push(...transformedValue);
+			else values.push(transformedValue);
+		}
+		return elementSql;
+	}
 	Object.entries(value).forEach(([field, val]) => {
-		const nextParamIndex = paramIndex + values.length;
-		let paramOperator;
-		let paramKey;
-		let paramValue;
-		if (field.startsWith("$")) {
-			paramOperator = field;
-			paramKey = "";
-			paramValue = val;
-		} else if (typeof val === "object" && !Array.isArray(val)) {
-			const [op, opValue] = Object.entries(val || {})[0] || [];
-			paramOperator = op;
-			paramKey = field;
-			paramValue = opValue;
-		} else {
-			paramOperator = "$eq";
-			paramKey = field;
-			paramValue = val;
-		}
-		const operatorFn = FILTER_OPERATORS[paramOperator];
-		if (!operatorFn) throw new Error(`Invalid operator: ${paramOperator}`);
-		const result = operatorFn(paramKey, nextParamIndex, paramValue);
-		const sql = result.sql.replaceAll("metadata->>", "elem->>").replaceAll("metadata->", "elem->").replaceAll("metadata#>>", "elem#>>").replaceAll("metadata#>", "elem#>");
-		conditions.push(sql);
-		if (result.needsValue) values.push(paramValue);
+		const operators = field.startsWith("$") ? [[field, val]] : typeof val === "object" && val !== null && !Array.isArray(val) ? Object.entries(val) : [["$eq", val]];
+		if (operators.length === 0) throw new Error(`$elemMatch field ${field} requires at least one operator`);
+		for (const [operator, operatorValue] of operators) conditions.push(buildFieldCondition(field, operator, operatorValue));
 	});
 	return {
 		sql: conditions.join(" AND "),
@@ -3405,12 +3403,16 @@ var PgDB = class extends MastraBase {
 				}
 				if (snapshot) {
 					snapshot.tables.add(tableName);
-					if (isNewTable) snapshot.createdTables.add(tableName);
-					const created = this.snapshotColumns(snapshot, tableName);
-					for (const [name, def] of Object.entries(schema)) {
-						const parsedName = parseSqlIdentifier(name, "column name");
-						created.add(parsedName);
-						if (def.type === "timestamp") created.add(`${parsedName}Z`);
+					if (isNewTable) {
+						snapshot.createdTables.add(tableName);
+						snapshot.columns.set(tableName, new Set(await this.getTableColumns(tableName)));
+					} else {
+						const created = this.snapshotColumns(snapshot, tableName);
+						for (const [name, def] of Object.entries(schema)) {
+							const parsedName = parseSqlIdentifier(name, "column name");
+							created.add(parsedName);
+							if (def.type === "timestamp") created.add(`${parsedName}Z`);
+						}
 					}
 				}
 			}
@@ -11655,6 +11657,13 @@ function dedupeMessagesForSave(messages) {
 	}
 	return Array.from(deduped.values());
 }
+/** Shallow merge; keys patched to `undefined` are dropped when serialized. Non-object metadata is replaced. */
+function mergeMetadata(existing, patch) {
+	return {
+		...existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {},
+		...patch
+	};
+}
 var MemoryPG = class MemoryPG extends MemoryStorage {
 	supportsPartialThreadUpdate = true;
 	supportsObservationalMemory = true;
@@ -11792,15 +11801,25 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 	* @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
 	*/
 	static getDefaultIndexDefs(schemaPrefix) {
-		return [{
-			name: `${schemaPrefix}mastra_threads_resourceid_createdat_idx`,
-			table: TABLE_THREADS,
-			columns: ["resourceId", "createdAt DESC"]
-		}, {
-			name: `${schemaPrefix}mastra_messages_thread_id_createdat_idx`,
-			table: TABLE_MESSAGES,
-			columns: ["thread_id", "createdAt DESC"]
-		}];
+		return [
+			{
+				name: `${schemaPrefix}mastra_threads_resourceid_createdat_idx`,
+				table: TABLE_THREADS,
+				columns: ["resourceId", "createdAt DESC"]
+			},
+			{
+				name: `${schemaPrefix}mastra_threads_metadata_gin_idx`,
+				table: TABLE_THREADS,
+				columns: ["metadata"],
+				method: "gin",
+				opclass: "jsonb_path_ops"
+			},
+			{
+				name: `${schemaPrefix}mastra_messages_thread_id_createdat_idx`,
+				table: TABLE_MESSAGES,
+				columns: ["thread_id", "createdAt DESC"]
+			}
+		];
 	}
 	/**
 	* Returns all DDL statements for this domain: tables (threads, messages, resources, OM), indexes.
@@ -12221,7 +12240,7 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 			const createdAt = toUtcISOString(thread.createdAt);
 			const updatedAt = toUtcISOString(thread.updatedAt);
 			const metadataJson = thread.metadata ? toPgJson(thread.metadata) : null;
-			await this.#fenced(fence, "saveThread", (q) => q.none(`INSERT INTO ${tableName} (
+			const saved = await this.#fenced(fence, "saveThread", (q) => q.oneOrNone(`INSERT INTO ${tableName} AS t (
           id,
           "resourceId",
           title,
@@ -12232,13 +12251,12 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
           "updatedAtZ"
         ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
         ON CONFLICT (id) DO UPDATE SET
-          "resourceId" = EXCLUDED."resourceId",
           title = EXCLUDED.title,
           metadata = EXCLUDED.metadata,
-          "createdAt" = EXCLUDED."createdAt",
-          "createdAtZ" = EXCLUDED."createdAtZ",
           "updatedAt" = EXCLUDED."updatedAt",
-          "updatedAtZ" = EXCLUDED."updatedAtZ"`, [
+          "updatedAtZ" = EXCLUDED."updatedAtZ"
+        WHERE t."resourceId" = EXCLUDED."resourceId"
+        RETURNING *`, [
 				thread.id,
 				thread.resourceId,
 				thread.title,
@@ -12248,12 +12266,26 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 				updatedAt,
 				updatedAt
 			]));
+			if (!saved) throw new MastraError({
+				id: createStorageErrorId("PG", "SAVE_THREAD", "RESOURCE_ID_MISMATCH"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				text: `Thread ${thread.id} already exists and belongs to a different resource. Use updateThreadResourceId to move a thread and its messages to another resource.`,
+				details: {
+					threadId: thread.id,
+					resourceId: thread.resourceId
+				}
+			});
 			return {
-				...thread,
-				metadata: metadataJson ? JSON.parse(metadataJson) : thread.metadata
+				id: saved.id,
+				resourceId: saved.resourceId,
+				title: saved.title,
+				metadata: saved.metadata == null ? void 0 : typeof saved.metadata === "string" ? JSON.parse(saved.metadata) : saved.metadata,
+				createdAt: saved.createdAtZ || saved.createdAt,
+				updatedAt: saved.updatedAtZ || saved.updatedAt
 			};
 		} catch (error) {
-			if (isRunFenceConflictError(error)) throw error;
+			if (error instanceof MastraError || isRunFenceConflictError(error)) throw error;
 			throw new MastraError({
 				id: createStorageErrorId("PG", "SAVE_THREAD", "FAILED"),
 				domain: ErrorDomain.STORAGE,
@@ -12262,52 +12294,125 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 			}, error);
 		}
 	}
-	async updateThread({ id, title, metadata, fence }) {
+	#toThread(row) {
+		return {
+			id: row.id,
+			resourceId: row.resourceId,
+			title: row.title,
+			metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
+			createdAt: row.createdAtZ || row.createdAt,
+			updatedAt: row.updatedAtZ || row.updatedAt
+		};
+	}
+	async #lockThread(t, tableName, { id, resourceId }) {
+		const params = [id];
+		let query = `SELECT * FROM ${tableName} WHERE id = $1`;
+		if (resourceId !== void 0) {
+			query += ` AND "resourceId" = $2`;
+			params.push(resourceId);
+		}
+		const row = await t.oneOrNone(`${query} FOR UPDATE`, params);
+		return row ? this.#toThread(row) : null;
+	}
+	/**
+	* Writes `title` (when given) and the full `metadata` value (when given).
+	* Callers that merge metadata must hold the row lock from `#lockThread`.
+	*/
+	async #writeThread(q, tableName, { id, title, metadata }) {
+		const nowStr = toUtcISOString(/* @__PURE__ */ new Date());
+		const params = [
+			title ?? null,
+			nowStr,
+			nowStr,
+			id
+		];
+		let metadataSet = "";
+		if (metadata !== void 0) {
+			params.push(toPgJson(metadata));
+			metadataSet = "metadata = $5,";
+		}
+		const row = await q.oneOrNone(`UPDATE ${tableName}
+       SET
+         title = COALESCE($1, title),
+         ${metadataSet}
+         "updatedAt" = $2,
+         "updatedAtZ" = $3
+       WHERE id = $4
+       RETURNING *`, params);
+		return row ? this.#toThread(row) : null;
+	}
+	/**
+	* Cross-process atomic metadata read-modify-write: the thread row stays locked
+	* (`SELECT ... FOR UPDATE`) from the read through the write, so concurrent
+	* writers from any process serialize instead of overwriting each other.
+	*/
+	async updateThreadMetadata({ id, resourceId, update, fence: explicitFence }) {
+		const fence = resolveRunFence(this, explicitFence);
+		const threadsTable = getTableName$3({
+			indexName: TABLE_THREADS,
+			schemaName: getSchemaName$3(this.#schema)
+		});
+		try {
+			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "updateThreadMetadata");
+				const thread = await this.#lockThread(t, threadsTable, {
+					id,
+					resourceId
+				});
+				if (!thread) return null;
+				const metadata = update(thread);
+				if (!metadata) return thread;
+				return this.#writeThread(t, threadsTable, {
+					id,
+					metadata: mergeMetadata(thread.metadata, metadata)
+				});
+			});
+		} catch (error) {
+			if (error instanceof MastraError || isRunFenceConflictError(error)) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("PG", "UPDATE_THREAD_METADATA", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId: id }
+			}, error);
+		}
+	}
+	async updateThread({ id, title, metadata, fence: explicitFence }) {
 		const threadTableName = getTableName$3({
 			indexName: TABLE_THREADS,
 			schemaName: getSchemaName$3(this.#schema)
 		});
+		const notFound = () => new MastraError({
+			id: createStorageErrorId("PG", "UPDATE_THREAD", "FAILED"),
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			text: `Thread ${id} not found`,
+			details: {
+				threadId: id,
+				title: title ?? null
+			}
+		});
 		try {
-			return await this.#fenced(fence, "updateThread", async (q) => {
-				const existingThread = await this.#getThreadById(q, { threadId: id });
-				if (!existingThread) throw new MastraError({
-					id: createStorageErrorId("PG", "UPDATE_THREAD", "FAILED"),
-					domain: ErrorDomain.STORAGE,
-					category: ErrorCategory.USER,
-					text: `Thread ${id} not found`,
-					details: {
-						threadId: id,
-						title: title ?? null
-					}
+			if (metadata === void 0) return await this.#fenced(explicitFence, "updateThread", async (q) => {
+				const thread = await this.#writeThread(q, threadTableName, {
+					id,
+					title
 				});
-				const mergedMetadata = {
-					...existingThread.metadata,
-					...metadata
-				};
-				const nowStr = toUtcISOString(/* @__PURE__ */ new Date());
-				const thread = await q.one(`UPDATE ${threadTableName}
-                    SET
-                        title = COALESCE($1, title),
-                        metadata = $2,
-                        "updatedAt" = $3,
-                        "updatedAtZ" = $4
-                    WHERE id = $5
-                    RETURNING *
-                `, [
-					title ?? null,
-					mergedMetadata,
-					nowStr,
-					nowStr,
-					id
-				]);
-				return {
-					id: thread.id,
-					resourceId: thread.resourceId,
-					title: thread.title,
-					metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-					createdAt: thread.createdAtZ || thread.createdAt,
-					updatedAt: thread.updatedAtZ || thread.updatedAt
-				};
+				if (!thread) throw notFound();
+				return thread;
+			});
+			const fence = resolveRunFence(this, explicitFence);
+			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "updateThread");
+				const existing = await this.#lockThread(t, threadTableName, { id });
+				if (!existing) throw notFound();
+				const thread = await this.#writeThread(t, threadTableName, {
+					id,
+					title,
+					metadata: mergeMetadata(existing.metadata, metadata)
+				});
+				if (!thread) throw notFound();
+				return thread;
 			});
 		} catch (error) {
 			if (error instanceof MastraError || isRunFenceConflictError(error)) throw error;
@@ -17363,8 +17468,12 @@ ${onConflict}`,
 async function insertRows(client, schema, table, records, partitioning, onConflict) {
 	const insert = buildInsert(schema, table, records, onConflict);
 	if (!insert) return;
+	await withPartitionRetry(client, schema, table, records, partitioning, () => client.query(insert.text, insert.values));
+}
+/** Retry a complete write after creating a missing native partition, outside any failed transaction. */
+async function withPartitionRetry(client, schema, table, records, partitioning, write) {
 	try {
-		await client.query(insert.text, insert.values);
+		return await write();
 	} catch (error) {
 		if (!isMissingPartitionError(error) || await resolveMode(client, partitioning) !== "native") throw error;
 		const days = withinPartitionWindow(recordDays(records, SIGNAL_TIME_COLUMN[table]), partitioning);
@@ -17377,7 +17486,7 @@ async function insertRows(client, schema, table, records, partitioning, onConfli
 				cause
 			}), { cause });
 		});
-		await client.query(insert.text, insert.values);
+		return await write();
 	}
 }
 /** `42501`: the role may not create the child, or does not own the parent it must attach to. */
@@ -18311,13 +18420,47 @@ function pushFeedbackIdentity(acc, feedbackType, feedbackSource) {
 	acc.conditions.push(`"valueNumber" IS NOT NULL`);
 }
 async function createFeedback(client, schema, args, partitioning) {
-	const row = feedbackRecordToRow(args.feedback);
-	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, [row], partitioning, FEEDBACK_UPSERT_CLAUSE);
+	await writeFeedback(client, schema, [args.feedback], args.onConflict, partitioning);
+}
+async function replaceFeedback(client, schema, args, partitioning) {
+	await writeFeedback(client, schema, [args.feedback], "replace", partitioning, true);
 }
 async function batchCreateFeedback(client, schema, args, partitioning) {
-	if (args.feedbacks.length === 0) return;
-	const rows = [...new Map(args.feedbacks.map((feedback) => [feedback.feedbackId, feedback])).values()].map(feedbackRecordToRow);
-	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, rows, partitioning, FEEDBACK_UPSERT_CLAUSE);
+	await writeFeedback(client, schema, args.feedbacks, args.onConflict, partitioning);
+}
+/** Serialize feedback writes by ID, including absent IDs and retries with a different timestamp. */
+async function writeFeedback(client, schema, feedbacks, onConflict, partitioning, preserveIdentity = false) {
+	if (!feedbacks.length) return;
+	const currentFeedback = new Map((onConflict === "ignore" ? [...feedbacks].reverse() : feedbacks).map((feedback) => [feedback.feedbackId, feedback]));
+	const rows = [...currentFeedback.values()].map(feedbackRecordToRow);
+	const ids = [...currentFeedback.keys()].sort();
+	await withPartitionRetry(client, schema, TABLE_FEEDBACK_EVENTS, rows, partitioning, () => client.tx(async (tx) => {
+		await tx.query(`SELECT pg_advisory_xact_lock(hashtextextended(lock_key, 0))
+         FROM unnest($1::text[]) WITH ORDINALITY AS locks(lock_key, position)
+         ORDER BY position`, [ids.map((id) => JSON.stringify([
+			schema,
+			TABLE_FEEDBACK_EVENTS,
+			id
+		]))]);
+		const existing = await tx.any(`SELECT DISTINCT ON ("feedbackId") "feedbackId", "traceId", "timestamp", "organizationId", "resourceId"
+         FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+         WHERE "feedbackId" = ANY($1::text[]) ORDER BY "feedbackId", "cursorId" DESC`, [ids]);
+		const byId = new Map(existing.map((row) => [row.feedbackId, row]));
+		const accepted = rows.filter((row) => {
+			const previous = byId.get(row.feedbackId);
+			if (!previous) return true;
+			if (onConflict === "ignore") return false;
+			if (preserveIdentity && (previous.traceId !== row.traceId || new Date(previous.timestamp).getTime() !== new Date(row.timestamp).getTime() || (previous.organizationId ?? null) !== (row.organizationId ?? null) || (previous.resourceId ?? null) !== (row.resourceId ?? null))) throw new MastraError({
+				id: "OBSERVABILITY_FEEDBACK_IDENTITY_CONFLICT",
+				domain: ErrorDomain.MASTRA_OBSERVABILITY,
+				category: ErrorCategory.USER,
+				text: "Feedback replacement must preserve its trace, timestamp, and tenant"
+			});
+			return true;
+		});
+		const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, accepted, FEEDBACK_UPSERT_CLAUSE);
+		if (insert) await tx.query(insert.text, insert.values);
+	}));
 }
 async function getFeedbackById(client, schema, feedbackId) {
 	const row = await client.oneOrNone(`SELECT ${FEEDBACK_SELECT_COLUMNS} FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
@@ -21795,6 +21938,7 @@ async function dangerouslyClearTracing(client, schema) {
 const spanQueryFeatures = typeof coreStorage.planSpanQuery === "function" ? [
 	"span-query",
 	"span-query-context-fields",
+	...coreStorage.SPAN_QUERY_ORDER_FIELDS?.includes("durationMs") ? ["span-query-duration-sort"] : [],
 	..."model" in (coreStorage.SPAN_QUERY_FIELD_REGISTRY ?? {}) ? ["span-query-model-fields"] : []
 ] : [];
 const spanAggregateFeatures = typeof coreStorage.planSpanAggregate === "function" ? ["span-aggregate", ..."model" in (coreStorage.SPAN_AGGREGATE_DIMENSION_REGISTRY ?? {}) ? ["span-aggregate-model-dimensions"] : []] : [];
@@ -22008,6 +22152,7 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"thread-query",
 			"trace-query-tenant-scope",
 			"feedback",
+			"feedback-replacement",
 			"trace-query-context-ids",
 			...contextFieldFeatures,
 			...timingFeatures,
@@ -22036,6 +22181,7 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"thread-query",
 			"trace-query-tenant-scope",
 			"feedback",
+			"feedback-replacement",
 			"trace-query-context-ids",
 			...contextFieldFeatures,
 			...timingFeatures,
@@ -22135,6 +22281,9 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async batchCreateScores(args) {
 		await this.#run("BATCH_CREATE_SCORES", () => batchCreateScores(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.scores.length });
 	}
+	async writeFeedbackReplacement(args) {
+		await this.#run("REPLACE_FEEDBACK", () => replaceFeedback(this.#client, this.#schema, args, this.#writePartitioning()));
+	}
 	async createFeedback(args) {
 		await this.#run("CREATE_FEEDBACK", () => createFeedback(this.#client, this.#schema, args, this.#writePartitioning()));
 	}
@@ -22160,7 +22309,7 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		return this.#run("GET_SCORE_BY_ID", () => getScoreById(this.#readClient, this.#schema, scoreId), { scoreId });
 	}
 	async getFeedbackById(feedbackId) {
-		return this.#run("GET_FEEDBACK_BY_ID", () => getFeedbackById(this.#readClient, this.#schema, feedbackId), { feedbackId });
+		return this.#run("GET_FEEDBACK_BY_ID", () => getFeedbackById(this.#client, this.#schema, feedbackId), { feedbackId });
 	}
 	async listFeedback(args) {
 		return this.#run("LIST_FEEDBACK", () => listFeedback(this.#readClient, this.#schema, args));
@@ -22861,6 +23010,8 @@ function rowToSchedule(row) {
 	if (metadata !== void 0) schedule.metadata = metadata;
 	if (row.owner_type != null) schedule.ownerType = String(row.owner_type);
 	if (row.owner_id != null) schedule.ownerId = String(row.owner_id);
+	if (row.run_at != null) schedule.runAt = Number(row.run_at);
+	if (row.end_at != null) schedule.endAt = Number(row.end_at);
 	return schedule;
 }
 function rowToTrigger(row) {
@@ -22920,6 +23071,11 @@ var SchedulesPG = class SchedulesPG extends SchedulesStorage {
 			tableName: TABLE_SCHEDULES,
 			schema: TABLE_SCHEMAS[TABLE_SCHEDULES]
 		});
+		await this.#db.alterTable({
+			tableName: TABLE_SCHEDULES,
+			schema: TABLE_SCHEMAS[TABLE_SCHEDULES],
+			ifNotExists: ["run_at", "end_at"]
+		});
 		await this.#db.createTable({
 			tableName: TABLE_SCHEDULE_TRIGGERS,
 			schema: TABLE_SCHEMAS[TABLE_SCHEDULE_TRIGGERS]
@@ -23047,7 +23203,9 @@ var SchedulesPG = class SchedulesPG extends SchedulesStorage {
 				updated_at: schedule.updatedAt,
 				metadata: schedule.metadata ?? null,
 				owner_type: schedule.ownerType ?? null,
-				owner_id: schedule.ownerId ?? null
+				owner_id: schedule.ownerId ?? null,
+				run_at: schedule.runAt ?? null,
+				end_at: schedule.endAt ?? null
 			}
 		});
 		return schedule;
@@ -23117,6 +23275,8 @@ var SchedulesPG = class SchedulesPG extends SchedulesStorage {
 		if ("metadata" in patch) push("metadata = ?::jsonb", patch.metadata != null ? toPgJson(patch.metadata) : null);
 		if ("ownerType" in patch) push("owner_type = ?", patch.ownerType ?? null);
 		if ("ownerId" in patch) push("owner_id = ?", patch.ownerId ?? null);
+		if ("runAt" in patch) push("run_at = ?", patch.runAt ?? null);
+		if ("endAt" in patch) push("end_at = ?", patch.endAt ?? null);
 		push("updated_at = ?", Date.now());
 		if (setClauses.length === 1) {
 			const existing = await this.#getSchedule(this.#client, id);