@protobase/server 0.8.0 → 0.8.2

package/dist/jobs/run-job.js

@@ -0,0 +1,78 @@
+//#region src/jobs/run-job.ts
+/** Thrown from a job's `run`, it fails the job now: the attempts it has left are not used. */
+var FatalJobError = class extends Error {
+	name = "FatalJobError";
+};
+/** The payload as the job's `payload` schema returns it, or why it does not pass. */
+const validatePayload = async (definition, payload) => {
+	const schema = definition.options.payload;
+	if (!schema) return { value: payload };
+	const result = await schema["~standard"].validate(payload);
+	if (!result.issues) return { value: result.value };
+	const issues = result.issues.map((issue) => {
+		const field = (issue.path ?? []).map((part) => String(typeof part === "object" ? part.key : part)).join(".");
+		return field ? `${field}: ${issue.message}` : issue.message;
+	});
+	return { invalid: `Job "${definition.name}" has an invalid payload: ${issues.join("; ")}` };
+};
+const checkPayload = async (definition, payload) => {
+	const checked = await validatePayload(definition, payload);
+	if ("invalid" in checked) throw new FatalJobError(checked.invalid);
+	return checked.value;
+};
+const readOnly = (error) => error?.code === "25006";
+const pause = (ms, signal) => new Promise((resolve) => {
+	if (signal.aborted) return resolve();
+	const timer = setTimeout(resolve, ms);
+	signal.addEventListener("abort", () => {
+		clearTimeout(timer);
+		resolve();
+	}, { once: true });
+});
+/** Runs `run` again every `waitMs` while the database is read-only, until the signal ends the try. */
+const throughWriteFreeze = async (run, signal, waitMs = 5e3) => {
+	for (;;) try {
+		return await run();
+	} catch (error) {
+		if (!readOnly(error) || signal.aborted) throw error;
+		await pause(waitMs, signal);
+	}
+};
+/** What a failed try keeps as the job's output, which the admin app shows as its last error. */
+const errorOutput = (error) => error instanceof Error ? {
+	name: error.name,
+	message: error.message,
+	...error.stack && { stack: error.stack }
+} : { message: String(error) };
+/**
+* One try of one job: completed when `run` returns, failed (to be retried while attempts are left) when it throws, and
+* failed for good on a `FatalJobError` or an invalid payload.
+*/
+const runJob = async (definition, job, db) => {
+	try {
+		const payload = await checkPayload(definition, job.data ?? void 0);
+		const context = {
+			db,
+			job: {
+				id: job.id,
+				name: job.name,
+				attempt: job.retryCount + 1,
+				maxAttempts: job.retryLimit + 1
+			},
+			signal: job.signal
+		};
+		await throughWriteFreeze(() => definition.options.run(payload, context), job.signal);
+		return {
+			id: job.id,
+			status: "completed"
+		};
+	} catch (error) {
+		return {
+			id: job.id,
+			status: error instanceof FatalJobError ? "deadletter" : "failed",
+			output: errorOutput(error)
+		};
+	}
+};
+//#endregion
+export { FatalJobError, runJob, throughWriteFreeze, validatePayload };

package/dist/jobs/runtime.d.ts

@@ -0,0 +1,46 @@
+import { JobDefinition } from "./job-types.js";
+import { JobsEnqueuer } from "./current.js";
+import { Db } from "@protobase/query";
+//#region src/jobs/runtime.d.ts
+export type StartJobsOptions = {
+  db: Db;
+  jobs: JobDefinition[];
+  /** Runs the jobs in this process; `false` only enqueues them, for a process whose jobs another one runs. Default true. */
+  work?: boolean;
+  /** Seconds between a worker's checks for due jobs; an enqueue outside a transaction wakes this process's worker at once. Default 2. */
+  pollSeconds?: number;
+  /** Seconds running jobs get to finish when the jobs stop, before they are failed and retried later. Default 30. */
+  shutdownSeconds?: number;
+  /** Gets every error the workers and the queue maintenance meet outside a job's own `run`. */
+  onError: (error: unknown) => void;
+  /** The time recurring jobs are scheduled from; tests pass their own. */
+  now?: () => Date;
+};
+/** What a drain left: whether no job is due or running any more, how many are, and when the next one is due. */
+export type DrainResult = {
+  drained: boolean;
+  remaining: number;
+  nextDue: Date | null;
+};
+export type JobsRuntime = JobsEnqueuer & {
+  /** Whether this process runs the jobs, or only enqueues them. */
+  readonly works: boolean;
+  /** Takes the project's jobs again, as `protobase dev` does when their files change. */
+  update(jobs: JobDefinition[]): Promise<void>;
+  /**
+   * Runs the jobs that are due until none is due or running, or `seconds` have passed: for a host that wakes a sleeping
+   * app to run its jobs. Needs this process to run jobs.
+   */
+  drain(seconds: number): Promise<DrainResult>;
+  /** When the next job is due, or `null` when none waits (`jobs.next_due()`). */
+  nextDue(): Promise<Date | null>;
+  /** Stops taking jobs, lets running ones finish within `shutdownSeconds`, then fails and releases the rest. */
+  stop(): Promise<void>;
+};
+/**
+ * Starts the app's jobs in this process: their queues, a worker per job unless `work` is false, and the maintenance
+ * that retries jobs whose worker died. It reads the jobs schema, never changes it: check it first with
+ * `checkJobsSchema`. Enqueueing through `defineJob(...).enqueue` reaches the runtime started here.
+ */
+export declare const startJobs: ({ db, jobs, work, pollSeconds, shutdownSeconds, onError, now }: StartJobsOptions) => Promise<JobsRuntime>;
+//#endregion

package/dist/jobs/runtime.js

@@ -0,0 +1,156 @@
+import { jobsSchema } from "./schema.js";
+import { clearCurrentJobs, setCurrentJobs } from "./current.js";
+import "./schedule.js";
+import { runJob, validatePayload } from "./run-job.js";
+import { jobsDatabase } from "./database.js";
+import { queueOptions, queueSettingsDiffer, sendOptions } from "./options.js";
+import { createSchedules } from "./schedules.js";
+import { sql } from "kysely";
+import { PgBoss } from "pg-boss";
+//#region src/jobs/runtime.ts
+const createBoss = (db, work) => new PgBoss({
+	db: jobsDatabase(db),
+	schema: jobsSchema,
+	migrate: false,
+	createSchema: false,
+	schedule: false,
+	supervise: work,
+	registerInstance: false,
+	reindex: false,
+	monitorVacuum: false,
+	useListenNotify: false
+});
+/**
+* Starts the app's jobs in this process: their queues, a worker per job unless `work` is false, and the maintenance
+* that retries jobs whose worker died. It reads the jobs schema, never changes it: check it first with
+* `checkJobsSchema`. Enqueueing through `defineJob(...).enqueue` reaches the runtime started here.
+*/
+const startJobs = async ({ db, jobs, work = true, pollSeconds = 2, shutdownSeconds = 30, onError, now = () => /* @__PURE__ */ new Date() }) => {
+	const boss = createBoss(db, work);
+	boss.on("error", onError);
+	await boss.start();
+	const schedules = createSchedules(boss, db, now);
+	const definitions = /* @__PURE__ */ new Map();
+	const workers = /* @__PURE__ */ new Map();
+	const ensureQueue = async (definition) => {
+		const wanted = queueOptions(definition.options);
+		const queue = await boss.getQueue(definition.name);
+		if (!queue) return boss.createQueue(definition.name, wanted);
+		if (queue.policy !== wanted.policy) throw new Error(`Job "${definition.name}" ${definition.options.ordered ? "became" : "is no longer"} ordered, but its queue keeps the old order. Let its jobs finish or delete them, drop the queue with \`select ${jobsSchema}.delete_queue('${definition.name}')\`, then start again.`);
+		if (queueSettingsDiffer(wanted, queue)) {
+			const { policy, ...settings } = wanted;
+			await boss.updateQueue(definition.name, settings);
+		}
+	};
+	const startWorker = async (definition) => {
+		const concurrency = definition.options.concurrency ?? 1;
+		const running = workers.get(definition.name);
+		if (running?.concurrency === concurrency) return;
+		if (running) await boss.offWork(definition.name);
+		const id = await boss.work(definition.name, {
+			batchSize: 1,
+			localConcurrency: concurrency,
+			pollingIntervalSeconds: pollSeconds,
+			includeMetadata: true,
+			perJobResults: true
+		}, async ([job]) => {
+			const current = definitions.get(definition.name) ?? definition;
+			if (current.options.schedule !== void 0 && job.singletonKey === "protobase.schedule") await schedules.following(current, job.startAfter);
+			return [await runJob(current, job, db)];
+		});
+		workers.set(definition.name, {
+			id,
+			concurrency
+		});
+	};
+	const update = async (next) => {
+		for (const definition of next) await ensureQueue(definition);
+		for (const name of definitions.keys()) {
+			if (next.some((definition) => definition.name === name)) continue;
+			definitions.delete(name);
+			if (workers.delete(name)) await boss.offWork(name);
+		}
+		for (const definition of next) definitions.set(definition.name, definition);
+		if (!work) return;
+		for (const definition of next) await startWorker(definition);
+		await schedules.sync(next);
+	};
+	const enqueue = async (definition, target, payload, options = {}) => {
+		const { name } = definition;
+		if (!definitions.has(name)) throw new Error(`Job "${name}" is not among the app's jobs; export it from the module protobase.config.ts passes as \`jobs\``);
+		const checked = await validatePayload(definition, payload);
+		if ("invalid" in checked) throw new Error(checked.invalid);
+		const data = checked.value ?? null;
+		const send = {
+			...sendOptions(definition.options, options),
+			db: jobsDatabase(target)
+		};
+		const keyed = async (key) => {
+			if (options.mode !== "replace") {
+				const [waiting] = await boss.findJobs(name, {
+					key,
+					queued: true,
+					db: send.db
+				});
+				if (waiting) return waiting.id;
+			}
+			return (await boss.upsert(name, data, send)).jobs[0];
+		};
+		const id = options.key === void 0 ? await boss.send(name, data, send) : await keyed(options.key);
+		if (!id) throw new Error(`Job "${name}" was not enqueued`);
+		if (!target.isTransaction) {
+			const worker = workers.get(name);
+			if (worker) boss.notifyWorker(worker.id);
+		}
+		return id;
+	};
+	const nextDue = async () => (await sql`select ${sql.id(jobsSchema, "next_due")}() as due`.execute(db)).rows[0].due;
+	const pending = async () => {
+		const job = sql.id(jobsSchema, "job");
+		const { rows } = await sql`
+      select count(*)::int as count from ${job} j where j.name = any(${[...definitions.keys()]}::text[]) and (
+        (j.state < 'active' and not j.blocked and j.start_after <= now()
+          and not (j.policy = 'key_strict_fifo' and exists (
+            select 1 from ${job} h where h.name = j.name and h.singleton_key = j.singleton_key and h.state = 'failed')))
+        or (j.state = 'active' and j.started_on + j.expire_seconds * interval '1s' > now()))`.execute(db);
+		return rows[0].count;
+	};
+	const drain = async (seconds) => {
+		if (!work) throw new Error("This process runs no jobs, so it cannot drain them");
+		const deadline = Date.now() + seconds * 1e3;
+		for (;;) {
+			for (const worker of workers.values()) boss.notifyWorker(worker.id);
+			const remaining = await pending();
+			if (remaining === 0 || Date.now() >= deadline) return {
+				drained: remaining === 0,
+				remaining,
+				nextDue: await nextDue()
+			};
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+	};
+	const runtime = {
+		works: work,
+		enqueue,
+		update,
+		drain,
+		nextDue,
+		stop: async () => {
+			await boss.stop({
+				graceful: true,
+				timeout: shutdownSeconds * 1e3
+			});
+			clearCurrentJobs(runtime);
+		}
+	};
+	try {
+		await update(jobs);
+		setCurrentJobs(runtime);
+	} catch (error) {
+		await boss.stop({ graceful: false });
+		throw error;
+	}
+	return runtime;
+};
+//#endregion
+export { startJobs };

package/dist/jobs/schedule.js

@@ -0,0 +1,25 @@
+import { createHash } from "node:crypto";
+import { CronExpressionParser } from "cron-parser";
+//#region src/jobs/schedule.ts
+/**
+* The key every run of a recurring job waits under. Each run is a job of its own, enqueued for its time: it is what
+* `jobs.next_due()` sees while the app sleeps, so a host that wakes the app for due jobs wakes it for these too.
+*/
+const scheduleKey = "protobase.schedule";
+/** The first run of `schedule` strictly after `after`, in `timezone`; throws on an expression cron-parser refuses. */
+const nextRun = (schedule, timezone, after) => CronExpressionParser.parse(schedule, {
+	currentDate: after,
+	tz: timezone
+}).next().toDate();
+/** Whether `at` is a run of `schedule`, so a run left from an earlier schedule can be told apart. */
+const isRun = (schedule, timezone, at) => nextRun(schedule, timezone, /* @__PURE__ */ new Date(at.getTime() - 1)).getTime() === at.getTime();
+/**
+* The id of the run of job `name` at `at`: the same in every process, so however many workers enqueue a run, the
+* database keeps one (its primary key), and the run happens once.
+*/
+const runId = (name, at) => {
+	const hex = createHash("sha256").update(`${name}@${at.toISOString()}`).digest("hex");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-8${hex.slice(13, 16)}-${(parseInt(hex[16], 16) & 3 | 8).toString(16)}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+};
+//#endregion
+export { isRun, nextRun, runId, scheduleKey };

package/dist/jobs/schedules.js

@@ -0,0 +1,41 @@
+import { jobsSchema } from "./schema.js";
+import { isRun, nextRun, runId, scheduleKey } from "./schedule.js";
+import { jobsDatabase } from "./database.js";
+import { sql } from "kysely";
+//#region src/jobs/schedules.ts
+const job = sql.id(jobsSchema, "job");
+/** The recurring jobs' runs: enqueued ahead, one per time, and kept in step with their schedules. */
+const createSchedules = (boss, db, now) => {
+	const timezone = (definition) => definition.options.timezone ?? "UTC";
+	const enqueueRun = (definition, at) => boss.send(definition.name, null, {
+		id: runId(definition.name, at),
+		startAfter: at,
+		singletonKey: scheduleKey,
+		db: jobsDatabase(db)
+	});
+	/**
+	* Makes the waiting runs match `definitions`: drops those of jobs without a schedule now, and those at a time the
+	* schedule no longer has, then enqueues each schedule's next run. A run that is due stays, to run as soon as it can.
+	*/
+	const sync = async (definitions) => {
+		const scheduled = definitions.filter((definition) => definition.options.schedule !== void 0);
+		await sql`delete from ${job} where singleton_key = ${scheduleKey} and state < 'active' and not (name = any(${scheduled.map(({ name }) => name)}::text[]))`.execute(db);
+		for (const definition of scheduled) {
+			const stale = (await sql`
+        select id, start_after from ${job} where name = ${definition.name} and singleton_key = ${scheduleKey} and state < 'active'`.execute(db)).rows.filter((run) => !isRun(definition.options.schedule, timezone(definition), new Date(run.start_after))).map((run) => run.id);
+			if (stale.length > 0) await sql`delete from ${job} where name = ${definition.name} and id = any(${stale}::uuid[])`.execute(db);
+			await enqueueRun(definition, nextRun(definition.options.schedule, timezone(definition), now()));
+		}
+	};
+	/** As a run starts, the one after it: from its own time, or from now when it ran late, so missed times are skipped. */
+	const following = async (definition, ranAt) => {
+		const from = new Date(Math.max(ranAt.getTime(), now().getTime()));
+		await enqueueRun(definition, nextRun(definition.options.schedule, timezone(definition), from));
+	};
+	return {
+		sync,
+		following
+	};
+};
+//#endregion
+export { createSchedules };

package/dist/jobs/schema.d.ts

@@ -0,0 +1,15 @@
+import { Db } from "@protobase/query";
+//#region src/jobs/schema.d.ts
+/** The schema the job queue lives in: pg-boss's tables and Protobase's functions. */
+export declare const jobsSchema = "jobs";
+/**
+ * The SQL that brings the jobs schema to what this version of Protobase runs: pg-boss's own construction plan when it
+ * is missing, or its migration plan from the version installed, then Protobase's functions. `undefined` when current.
+ */
+export declare const jobsSchemaMigration: (db: Db) => Promise<string | undefined>;
+/**
+ * Refuses to go on while the jobs schema is missing or not the version this Protobase runs. The server never creates
+ * or migrates it: the project's migrations do, before the new version serves.
+ */
+export declare const checkJobsSchema: (db: Db) => Promise<void>;
+//#endregion

package/dist/jobs/schema.js

@@ -0,0 +1,63 @@
+import { functionNames, functionsComment, functionsSql } from "./functions-sql.js";
+import { CompiledQuery } from "kysely";
+import { getConstructionPlans, getMigrationPlans } from "pg-boss";
+//#region src/jobs/schema.ts
+/** The schema the job queue lives in: pg-boss's tables and Protobase's functions. */
+const jobsSchema = "jobs";
+/** The command that writes what the database lacks as the project's next migration. */
+const migrationCommand = "protobase migration";
+/**
+* A pg-boss plan as a migration the project applies in its own transaction: without its BEGIN and COMMIT, without the
+* timeouts it sets for that transaction, which would hold for the project's later migrations too, and with index
+* builds that are not `CONCURRENTLY`, which Postgres refuses in a transaction. Migrations run while nothing else
+* writes, so a plain index build only costs a lock nobody waits on.
+*/
+const migrationStatements = (plan) => {
+	const match = /^\s*BEGIN;\n\s*SET LOCAL lock_timeout = \d+;\n\s*SET LOCAL idle_in_transaction_session_timeout = \d+;\n([\s\S]*?)\n\s*COMMIT;\n?([\s\S]*)$/.exec(plan);
+	if (!match) throw new Error(`Unexpected pg-boss plan:\n${plan.slice(0, 200)}`);
+	return `${match[1].trim()}\n${match[2]}`.replace(/\b(CREATE (?:UNIQUE )?INDEX|DROP INDEX|REINDEX INDEX) CONCURRENTLY\b/gi, "$1").trim();
+};
+const rows = async (db, text, parameters = []) => (await db.executeQuery(CompiledQuery.raw(text, parameters))).rows;
+/** What the database holds of the jobs schema: pg-boss's version, when installed, and whether Protobase's functions are current. */
+const readJobsSchema = async (db) => {
+	const [{ installed }] = await rows(db, `select to_regclass('${jobsSchema}.version') is not null as installed`);
+	if (!installed) return {
+		pgBoss: void 0,
+		functionsCurrent: false
+	};
+	const [version] = await rows(db, `select version from ${jobsSchema}.version`);
+	const functions = await rows(db, `select p.proname as name, obj_description(p.oid, 'pg_proc') as comment from pg_proc p
+     join pg_namespace n on n.oid = p.pronamespace where n.nspname = $1 and p.proname = any($2)`, [jobsSchema, functionNames]);
+	const functionsCurrent = functionNames.every((name) => functions.some((found) => found.name === name && found.comment === functionsComment));
+	return {
+		pgBoss: version === void 0 ? void 0 : Number(version.version),
+		functionsCurrent
+	};
+};
+const newer = (version) => /* @__PURE__ */ new Error(`The jobs schema is at pg-boss schema version ${version}, newer than the 45 this version of Protobase runs; upgrade Protobase`);
+/**
+* The SQL that brings the jobs schema to what this version of Protobase runs: pg-boss's own construction plan when it
+* is missing, or its migration plan from the version installed, then Protobase's functions. `undefined` when current.
+*/
+const jobsSchemaMigration = async (db) => {
+	const { pgBoss, functionsCurrent } = await readJobsSchema(db);
+	if (pgBoss !== void 0 && pgBoss > 45) throw newer(pgBoss);
+	if (pgBoss === 45 && functionsCurrent) return void 0;
+	const parts = [];
+	if (pgBoss === void 0) parts.push(migrationStatements(getConstructionPlans(jobsSchema)));
+	else if (pgBoss < 45) parts.push(migrationStatements(getMigrationPlans(jobsSchema, pgBoss)));
+	parts.push(functionsSql(jobsSchema));
+	return parts.join("\n\n");
+};
+/**
+* Refuses to go on while the jobs schema is missing or not the version this Protobase runs. The server never creates
+* or migrates it: the project's migrations do, before the new version serves.
+*/
+const checkJobsSchema = async (db) => {
+	const { pgBoss, functionsCurrent } = await readJobsSchema(db);
+	if (pgBoss !== void 0 && pgBoss > 45) throw newer(pgBoss);
+	if (pgBoss === 45 && functionsCurrent) return;
+	throw new Error(`The jobs schema is ${pgBoss === void 0 ? "missing" : "behind this version of Protobase"}. Write it as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
+};
+//#endregion
+export { checkJobsSchema, jobsSchema, jobsSchemaMigration, migrationCommand, migrationStatements, readJobsSchema };

package/dist/project-config.d.ts

@@ -1,4 +1,5 @@
 import { AdminAuth } from "./better-auth/create-auth.js";
+import { EventsOptions } from "./changes/events-options.js";
 import { FilesOptions } from "./files/options.js";
 import { Authenticator } from "./types.js";
 import { FunctionSource } from "./functions/define-function.js";
@@ -21,13 +22,17 @@ export type ProjectConfig = {
   functions?: Record<string, FunctionSource>;
   /** Where file fields keep their bytes: providers by name, retention and the signing secret (see `FilesOptions`). */
   files?: FilesOptions;
+  /** Where the changes that resources' events are raised from are captured (see `EventsOptions`). */
+  events?: EventsOptions;
+  /** The module of the app's jobs, e.g. `import * as jobs from './config/jobs'`: every `defineJob` it exports. */
+  jobs?: Record<string, unknown>;
   options?: AdminOptions;
 };
 /** Typed identity, for `export default defineConfig({ extends: [...], config, auth, ... })` in `protobase.config.ts`. */
 export declare const defineConfig: (config: ProjectConfig) => ProjectConfig;
 /**
  * One config from several, each after the ones it `extends`, the last being the app's own. Named things are all kept:
- * resources, views and pages of the config modules, functions, assistant tools, file providers; one name defined by two configs is an error naming
+ * resources, views and pages of the config modules, functions, jobs, assistant tools, file providers; one name defined by two configs is an error naming
  * both. Write hooks run in the same order. Every other value is the last config's that sets it, so the app's own wins.
  */
 export declare const mergeConfig: (...configs: ProjectConfig[]) => ProjectConfig;

package/dist/project-config.js

@@ -1,3 +1,4 @@
+import { jobDefinitions } from "./jobs/define-job.js";
 import { isPageDefinition } from "@protobase/layout";
 //#region src/project-config.ts
 /** Typed identity, for `export default defineConfig({ extends: [...], config, auth, ... })` in `protobase.config.ts`. */
@@ -104,6 +105,16 @@ const mergedFiles = (named) => {
 		...secret !== void 0 && { secret }
 	};
 };
+const mergedJobs = (named) => {
+	const all = named.flatMap(({ config, label }) => jobDefinitions(config.jobs ?? {}).map((value) => ({
+		name: value.name,
+		value,
+		label
+	})));
+	if (all.length === 0) return void 0;
+	checkUnique("The job", all);
+	return Object.fromEntries(all.map(({ name, value }) => [name, value]));
+};
 const mergedOptions = (named) => {
 	const all = named.flatMap(({ config }) => config.options ? [config.options] : []);
 	if (all.length === 0) return void 0;
@@ -117,19 +128,21 @@ const mergedOptions = (named) => {
 };
 /**
 * One config from several, each after the ones it `extends`, the last being the app's own. Named things are all kept:
-* resources, views and pages of the config modules, functions, assistant tools, file providers; one name defined by two configs is an error naming
+* resources, views and pages of the config modules, functions, jobs, assistant tools, file providers; one name defined by two configs is an error naming
 * both. Write hooks run in the same order. Every other value is the last config's that sets it, so the app's own wins.
 */
 const mergeConfig = (...configs) => {
 	const named = configs.flatMap((config, index) => flatten(config, config.name ?? `config ${index + 1}`));
-	const { db, authenticate, auth } = lastSet(named.map(({ config }) => ({
+	const { db, authenticate, auth, events } = lastSet(named.map(({ config }) => ({
 		db: config.db,
 		authenticate: config.authenticate,
-		auth: config.auth
+		auth: config.auth,
+		events: config.events
 	})));
 	const module = mergedModule(named);
 	const functions = mergedFunctions(named);
 	const files = mergedFiles(named);
+	const jobs = mergedJobs(named);
 	const options = mergedOptions(named);
 	const name = configs.at(-1)?.name;
 	return {
@@ -140,6 +153,8 @@ const mergeConfig = (...configs) => {
 		...auth && { auth },
 		...functions && { functions },
 		...files && { files },
+		...events && { events },
+		...jobs && { jobs },
 		...options && { options }
 	};
 };

package/dist/transactions.js

@@ -1,8 +1,15 @@
 import { sql } from "kysely";
 //#region src/transactions.ts
-/** One transaction whose statements Postgres cancels after `timeoutMs` (SET LOCAL statement_timeout). */
-const writeTransaction = (db, timeoutMs, run) => db.transaction().execute(async (trx) => {
-	await sql`select set_config('statement_timeout', ${String(timeoutMs)}, true)`.execute(trx);
+/**
+* One transaction whose statements Postgres cancels after `timeoutMs` (SET LOCAL statement_timeout), with `settings`
+* set for it as well, all in one statement.
+*/
+const writeTransaction = (db, timeoutMs, run, settings = {}) => db.transaction().execute(async (trx) => {
+	const all = Object.entries({
+		statement_timeout: String(timeoutMs),
+		...settings
+	});
+	await sql`select ${sql.join(all.map(([name, value]) => sql`set_config(${name}, ${value}, true)`))}`.execute(trx);
 	return run(trx);
 });
 /** Same, and Postgres refuses any write inside it. */

package/dist/write-pipeline.js

@@ -4,6 +4,7 @@ import { tenantScope } from "./tenant.js";
 import { requestAccess, requireOperation, targetFilter, writableFields } from "./request-access.js";
 import { writeTransaction } from "./transactions.js";
 import { attachFiles } from "./files/attach.js";
+import { actorSettings } from "./changes/actor.js";
 import { validateBody } from "./validate-body.js";
 import { assertWritten, checkPrecondition, decide, denied, firstKeyField, missing, notifier, shown } from "./write-shared.js";
 import { applyUpdate, planUpdate } from "./write-update.js";
@@ -89,7 +90,7 @@ const writeIn = async (trx, deps, access, request) => {
 const runWrite = async (deps, entry, session, request) => {
 	const access = await requestAccess(deps, entry, session);
 	requireOperation(access, request.operation === "undelete" ? "update" : request.operation);
-	return writeTransaction(deps.db, deps.statementTimeoutMs, (trx) => writeIn(trx, deps, access, request));
+	return writeTransaction(deps.db, deps.statementTimeoutMs, (trx) => writeIn(trx, deps, access, request), actorSettings(deps, session));
 };
 //#endregion
 export { runWrite, writeIn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -30,18 +30,20 @@
   },
   "dependencies": {
     "@better-auth/passkey": "^1.7.7",
-    "@protobase/layout": "0.8.0",
-    "@protobase/query": "0.8.0",
-    "@protobase/schema": "0.8.0",
+    "@protobase/layout": "0.8.2",
+    "@protobase/query": "0.8.2",
+    "@protobase/schema": "0.8.2",
     "@scalar/hono-api-reference": "^0.12.10",
     "@simplewebauthn/server": "^13.3.1",
     "better-auth": "^1.7.7",
+    "cron-parser": "^5.10.1",
     "file-type": "^22.1.1",
     "hono": "^4.13.13",
     "image-size": "^2.0.4",
     "jose": "^6.2.12",
     "kysely": "^0.29.6",
     "nodemailer": "^10.0.16",
+    "pg-boss": "12.37.1",
     "zod": "^4.6.5"
   }
 }