@plitzi/sdk-server 0.37.1 → 0.37.3

package/dist/modules/mongo/jobQueue.d.ts

@@ -0,0 +1,38 @@
+import { ActionJobQueue } from '@plitzi/sdk-shared';
+import { Db } from 'mongodb';
+/** The database, or how to reach it — a getter for a deployment whose client is replaced when it reconnects. */
+export type MongoDbSource = Db | (() => Db);
+export declare const resolveDb: (source: MongoDbSource) => Db;
+export type MongoJobQueueOptions = {
+    db: MongoDbSource;
+    /** Collection names, for a deployment with a naming scheme of its own. */
+    collections?: {
+        jobs?: string;
+        schedules?: string;
+    };
+    /** How long a finished job stays readable. A waiting or running one never expires. Default 90 days. */
+    retentionDays?: number;
+};
+export type MongoJobQueue = ActionJobQueue & {
+    /** Takes the store's clock again on the next call — after a failover to another primary. */
+    resyncClock: () => void;
+};
+/**
+ * An {@link ActionJobQueue} over two collections of a Mongo database the deployment owns.
+ *
+ * The helper for a deployment that already runs Mongo: it holds no connection of its own and creates nothing but the
+ * indexes its queries need, on first use. Every replica pointed at the same database shares the jobs and the
+ * schedules, which is what running more than one needs.
+ *
+ * ```ts
+ * import { createMongoJobQueue } from '@plitzi/sdk-server/mongo';
+ *
+ * const queue = createMongoJobQueue({ db: client.db('app') });
+ * createServer({ action: { lookups, kv, jobs: { queue } } });
+ * ```
+ *
+ * The contract's rules, as Mongo keeps them: every instant is the SERVER's (`hello.localTime`), `enqueue` is idempotent
+ * by the job's `_id`, `claim` takes one document per `findOneAndUpdate` — the atomic unit — and reaps a lapsed lease in
+ * the same operation, and a schedule advances by compare-and-set on the instant that was read.
+ */
+export declare const createMongoJobQueue: ({ db, collections: names, retentionDays }: MongoJobQueueOptions) => MongoJobQueue;

package/dist/modules/mongo/jobQueue.js

@@ -0,0 +1,335 @@
+import { createStoreClock } from "../actions/jobs/storeClock.js";
+//#region src/modules/mongo/jobQueue.ts
+/** Mongo's code for a unique index that refused a second document with the same key. */
+var DUPLICATE_KEY = 11e3;
+var TERMINAL = [
+	"succeeded",
+	"failed",
+	"dead",
+	"cancelled"
+];
+var DAY_MS = 864e5;
+var resolveDb = (source) => typeof source === "function" ? source() : source;
+var scheduleId = (spaceId, actionId) => `${spaceId}:${actionId}`;
+/**
+* A stored document as the contract shapes it: an optional field is absent, never `null`.
+*
+* Mongo keeps what a `$set` wrote, and clearing a field in an update pipeline writes `null` — so a released job would
+* otherwise come back with `workerId: null`, which every reader typed as `string | undefined` gets wrong.
+*/
+var withoutNulls = (document) => Object.fromEntries(Object.entries(document).filter(([, value]) => value !== null));
+var toJob = ({ _id, expiresAt: _expiresAt, ...rest }) => withoutNulls({
+	...rest,
+	id: _id
+});
+var toSchedule = ({ _id: _unused, ...rest }) => withoutNulls(rest);
+/** The history entry a reclaim writes on behalf of a worker that never came back. */
+var lostAttempt = (at) => ({ $concatArrays: ["$history", [{
+	attempt: { $add: [{ $size: "$history" }, 1] },
+	status: "lost",
+	startedAt: "$updatedAt",
+	endedAt: at,
+	workerId: { $ifNull: ["$workerId", "unknown"] },
+	error: "the worker holding this job stopped reporting"
+}]] });
+/**
+* An {@link ActionJobQueue} over two collections of a Mongo database the deployment owns.
+*
+* The helper for a deployment that already runs Mongo: it holds no connection of its own and creates nothing but the
+* indexes its queries need, on first use. Every replica pointed at the same database shares the jobs and the
+* schedules, which is what running more than one needs.
+*
+* ```ts
+* import { createMongoJobQueue } from '@plitzi/sdk-server/mongo';
+*
+* const queue = createMongoJobQueue({ db: client.db('app') });
+* createServer({ action: { lookups, kv, jobs: { queue } } });
+* ```
+*
+* The contract's rules, as Mongo keeps them: every instant is the SERVER's (`hello.localTime`), `enqueue` is idempotent
+* by the job's `_id`, `claim` takes one document per `findOneAndUpdate` — the atomic unit — and reaps a lapsed lease in
+* the same operation, and a schedule advances by compare-and-set on the instant that was read.
+*/
+var createMongoJobQueue = ({ db, collections: names = {}, retentionDays = 90 }) => {
+	const jobsName = names.jobs ?? "action_jobs";
+	const schedulesName = names.schedules ?? "action_schedules";
+	const jobsOf = () => resolveDb(db).collection(jobsName);
+	const schedulesOf = () => resolveDb(db).collection(schedulesName);
+	const clock = createStoreClock(async () => {
+		const { localTime } = await resolveDb(db).command({ hello: 1 });
+		return localTime ? localTime.getTime() : Date.now();
+	});
+	let ready;
+	/**
+	* The indexes the queue cannot work without, built once on first use.
+	*
+	* `claim` is the one that matters: it runs on every poll of every replica, and without an index over status and the
+	* two time fields it is a collection scan several times a second. The two branches of its `$or` are answered by one
+	* index each and merged already sorted.
+	*/
+	const build = async () => {
+		await Promise.all([
+			jobsOf().createIndex({
+				status: 1,
+				runAt: 1
+			}),
+			jobsOf().createIndex({
+				status: 1,
+				leaseUntil: 1
+			}),
+			jobsOf().createIndex({
+				spaceId: 1,
+				updatedAt: -1
+			}),
+			jobsOf().createIndex({
+				spaceId: 1,
+				actionId: 1,
+				updatedAt: -1
+			}),
+			jobsOf().createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 }),
+			schedulesOf().createIndex({
+				enabled: 1,
+				nextRunAt: 1
+			}),
+			schedulesOf().createIndex({ spaceId: 1 })
+		]);
+	};
+	const collections = async () => {
+		ready ??= build().catch((error) => {
+			ready = void 0;
+			throw error;
+		});
+		await ready;
+		return {
+			jobs: jobsOf(),
+			schedules: schedulesOf()
+		};
+	};
+	const expiryOf = (at) => new Date(at + retentionDays * DAY_MS);
+	return {
+		resyncClock: clock.resync,
+		now: async () => new Date(await clock.now()),
+		enqueue: async (job) => {
+			const { jobs } = await collections();
+			const at = await clock.now();
+			const { id, ...fields } = job;
+			const document = {
+				...fields,
+				_id: id,
+				status: "pending",
+				runAt: job.dueAt,
+				attempts: 0,
+				createdAt: at,
+				updatedAt: at,
+				history: []
+			};
+			try {
+				await jobs.insertOne(document);
+				return true;
+			} catch (error) {
+				if (error.code === DUPLICATE_KEY) return false;
+				throw error;
+			}
+		},
+		claim: async ({ workerId, leaseMs, limit }) => {
+			const { jobs } = await collections();
+			const at = await clock.now();
+			const taken = [];
+			for (let slot = 0; slot < limit; slot += 1) {
+				const claimed = await jobs.findOneAndUpdate({ $or: [{
+					status: "pending",
+					runAt: { $lte: at }
+				}, {
+					status: "running",
+					leaseUntil: { $lt: at }
+				}] }, [{ $set: { history: { $cond: [
+					{ $eq: ["$status", "running"] },
+					lostAttempt(at),
+					"$history"
+				] } } }, { $set: {
+					status: "running",
+					workerId,
+					leaseUntil: at + leaseMs,
+					updatedAt: at,
+					attempts: { $add: ["$attempts", 1] }
+				} }], {
+					sort: { runAt: 1 },
+					returnDocument: "after"
+				});
+				if (!claimed) break;
+				taken.push(toJob(claimed));
+			}
+			return taken;
+		},
+		heartbeat: async ({ jobIds, workerId, leaseMs }) => {
+			const { jobs } = await collections();
+			const at = await clock.now();
+			await jobs.updateMany({
+				_id: { $in: jobIds },
+				workerId,
+				status: "running"
+			}, { $set: { leaseUntil: at + leaseMs } });
+			return (await jobs.find({
+				_id: { $in: jobIds },
+				workerId,
+				status: "running",
+				cancelRequested: true
+			}).project({ _id: 1 }).toArray()).map((job) => job._id);
+		},
+		settle: async ({ jobId, workerId, status, delayMs, runId, error, attempt }) => {
+			const { jobs } = await collections();
+			const at = await clock.now();
+			const entry = {
+				attempt: { $add: [{ $size: "$history" }, 1] },
+				startedAt: "$updatedAt",
+				endedAt: at,
+				...attempt
+			};
+			await jobs.updateOne({
+				_id: jobId,
+				workerId
+			}, [{ $set: {
+				...attempt ? { history: { $concatArrays: ["$history", [entry]] } } : {},
+				status,
+				updatedAt: at,
+				leaseUntil: null,
+				error: error ?? null,
+				...runId ? { runId } : {},
+				...status === "pending" ? {
+					runAt: at + (delayMs ?? 0),
+					workerId: null,
+					...attempt ? {} : { attempts: { $max: [0, { $subtract: ["$attempts", 1] }] } }
+				} : {},
+				expiresAt: TERMINAL.includes(status) ? expiryOf(at) : null
+			} }]);
+		},
+		dueSchedules: async (limit) => {
+			const { schedules } = await collections();
+			const at = await clock.now();
+			return (await schedules.find({
+				enabled: true,
+				nextRunAt: { $lte: at }
+			}).sort({ nextRunAt: 1 }).limit(limit).toArray()).map(toSchedule);
+		},
+		advanceSchedule: async ({ spaceId, actionId, from, to, missed }) => {
+			const { schedules } = await collections();
+			const at = await clock.now();
+			return (await schedules.updateOne({
+				_id: scheduleId(spaceId, actionId),
+				nextRunAt: from
+			}, {
+				$set: {
+					nextRunAt: to,
+					lastFireAt: from,
+					updatedAt: at
+				},
+				$inc: { missed }
+			})).matchedCount === 1;
+		},
+		putSchedules: async ({ spaceId, schedules: incoming }) => {
+			const { schedules } = await collections();
+			const at = await clock.now();
+			if (incoming.length > 0) await schedules.bulkWrite(incoming.map((schedule) => ({ updateOne: {
+				filter: { _id: scheduleId(spaceId, schedule.actionId) },
+				update: [{ $set: {
+					...schedule,
+					timezone: schedule.timezone ?? null,
+					updatedAt: at,
+					missed: { $ifNull: ["$missed", 0] },
+					nextRunAt: { $cond: [
+						{ $and: [
+							{ $eq: ["$cron", schedule.cron] },
+							{ $eq: [{ $ifNull: ["$timezone", null] }, schedule.timezone ?? null] },
+							{ $eq: ["$environment", schedule.environment] },
+							{ $ne: [{ $ifNull: ["$nextRunAt", null] }, null] }
+						] },
+						"$nextRunAt",
+						schedule.nextRunAt
+					] }
+				} }],
+				upsert: true
+			} })));
+			await schedules.deleteMany({
+				spaceId,
+				actionId: { $nin: incoming.map((schedule) => schedule.actionId) }
+			});
+		},
+		listJobs: async ({ spaceIds, actionId, status, limit, offset }) => {
+			const { jobs } = await collections();
+			const filter = {
+				spaceId: { $in: spaceIds },
+				...actionId ? { actionId } : {},
+				...status ? { status } : {}
+			};
+			const [found, total] = await Promise.all([jobs.find(filter).sort({
+				updatedAt: -1,
+				_id: -1
+			}).skip(offset).limit(limit).toArray(), jobs.countDocuments(filter)]);
+			return {
+				jobs: found.map(toJob),
+				total
+			};
+		},
+		getJob: async (spaceIds, jobId) => {
+			const { jobs } = await collections();
+			const job = await jobs.findOne({
+				_id: jobId,
+				spaceId: { $in: spaceIds }
+			});
+			return job ? toJob(job) : void 0;
+		},
+		listSchedules: async (spaceIds) => {
+			const { schedules } = await collections();
+			return (await schedules.find({ spaceId: { $in: spaceIds } }).sort({ nextRunAt: 1 }).toArray()).map(toSchedule);
+		},
+		requeue: async (spaceIds, jobId) => {
+			const { jobs } = await collections();
+			const at = await clock.now();
+			return (await jobs.updateOne({
+				_id: jobId,
+				spaceId: { $in: spaceIds },
+				status: { $in: TERMINAL }
+			}, {
+				$set: {
+					status: "pending",
+					runAt: at,
+					attempts: 0,
+					updatedAt: at,
+					cancelRequested: false
+				},
+				$unset: {
+					workerId: "",
+					leaseUntil: "",
+					error: "",
+					expiresAt: ""
+				}
+			})).matchedCount === 1;
+		},
+		cancel: async (spaceIds, jobId) => {
+			const { jobs } = await collections();
+			const at = await clock.now();
+			if ((await jobs.updateOne({
+				_id: jobId,
+				spaceId: { $in: spaceIds },
+				status: "pending"
+			}, {
+				$set: {
+					status: "cancelled",
+					updatedAt: at,
+					expiresAt: expiryOf(at)
+				},
+				$unset: { workerId: "" }
+			})).matchedCount === 1) return true;
+			return (await jobs.updateOne({
+				_id: jobId,
+				spaceId: { $in: spaceIds },
+				status: "running"
+			}, { $set: {
+				cancelRequested: true,
+				updatedAt: at
+			} })).matchedCount === 1;
+		}
+	};
+};
+//#endregion
+export { createMongoJobQueue, resolveDb };

package/dist/modules/mongo/kv.d.ts

@@ -0,0 +1,15 @@
+import { MongoDbSource } from './jobQueue';
+import { ActionKvAdapter } from '../actions/types';
+export type MongoKvOptions = {
+    db: MongoDbSource;
+    /** Default `action_kv`. */
+    collection?: string;
+};
+/**
+ * An {@link ActionKvAdapter} over a collection of a Mongo database the deployment owns.
+ *
+ * What the run guards' single-flight keys and the `kv` tasks' counters need from a store the replicas share: a TTL the
+ * store enforces and an increment nobody can race. Each operation is ONE document update, which Mongo applies
+ * atomically — so two replicas incrementing the same counter at once both count.
+ */
+export declare const createMongoKv: ({ db, collection }: MongoKvOptions) => ActionKvAdapter;

package/dist/modules/mongo/kv.js

@@ -0,0 +1,129 @@
+import { resolveDb } from "./jobQueue.js";
+//#region src/modules/mongo/kv.ts
+/** Mongo's code for a unique index that refused a second document with the same key. */
+var DUPLICATE_KEY = 11e3;
+/**
+* Whether a key is still alive, by the SERVER's clock.
+*
+* Mongo's TTL monitor sweeps once a minute, so a document past its lifetime can still be there to read. Expiry is
+* decided here, against `$$NOW`, rather than by whether the sweeper has been round yet — the same answer Redis gives
+* the instant a key lapses.
+*/
+var LIVE = { $or: [{ $eq: [{ $ifNull: ["$expiresAt", null] }, null] }, { $gt: ["$expiresAt", "$$NOW"] }] };
+var expiryIn = (ttlSeconds) => ({ $add: ["$$NOW", ttlSeconds * 1e3] });
+/**
+* An {@link ActionKvAdapter} over a collection of a Mongo database the deployment owns.
+*
+* What the run guards' single-flight keys and the `kv` tasks' counters need from a store the replicas share: a TTL the
+* store enforces and an increment nobody can race. Each operation is ONE document update, which Mongo applies
+* atomically — so two replicas incrementing the same counter at once both count.
+*/
+var createMongoKv = ({ db, collection = "action_kv" }) => {
+	const keys = () => resolveDb(db).collection(collection);
+	let ready;
+	const store = async () => {
+		ready ??= keys().createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 }).then(() => void 0).catch((error) => {
+			ready = void 0;
+			throw error;
+		});
+		await ready;
+		return keys();
+	};
+	/**
+	* An upsert two replicas race for can collide on `_id` before either has written; the server retries that itself
+	* from 4.2 on, and this covers the rest. Once is enough: the second attempt finds the document the first one made.
+	*/
+	const upserting = async (write) => {
+		try {
+			return await write();
+		} catch (error) {
+			if (error.code !== DUPLICATE_KEY) throw error;
+			return write();
+		}
+	};
+	return {
+		get: async (key) => {
+			return (await (await store()).findOne({
+				_id: key,
+				$expr: LIVE
+			}))?.value;
+		},
+		set: async (key, value, ttlSeconds) => {
+			const keysNow = await store();
+			await upserting(() => keysNow.updateOne({ _id: key }, [{ $set: {
+				value,
+				expiresAt: ttlSeconds === void 0 ? null : expiryIn(ttlSeconds)
+			} }], { upsert: true }));
+		},
+		delete: async (key) => {
+			await (await store()).deleteOne({ _id: key });
+		},
+		increment: async (key, amount) => {
+			const keysNow = await store();
+			const updated = await upserting(() => keysNow.findOneAndUpdate({ _id: key }, [
+				{ $set: { live: LIVE } },
+				{ $set: {
+					value: { $toString: { $add: [{ $cond: [
+						"$live",
+						{ $convert: {
+							input: "$value",
+							to: "double",
+							onError: 0,
+							onNull: 0
+						} },
+						0
+					] }, amount] } },
+					expiresAt: { $cond: [
+						"$live",
+						{ $ifNull: ["$expiresAt", null] },
+						null
+					] }
+				} },
+				{ $unset: "live" }
+			], {
+				upsert: true,
+				returnDocument: "after"
+			}));
+			return Number(updated?.value ?? amount);
+		},
+		expire: async (key, ttlSeconds) => {
+			await (await store()).updateOne({
+				_id: key,
+				$expr: LIVE
+			}, [{ $set: { expiresAt: expiryIn(ttlSeconds) } }]);
+		},
+		/**
+		* Each branch is one update Mongo applies to the document atomically. Expecting a value, the filter names it.
+		* Expecting nothing is two cases: a lapsed document, taken over by a filter that matches only a lapsed one; and no
+		* document, inserted by an upsert whose filter no stored document satisfies — so a live one makes it collide on
+		* `_id`, which is the refusal, not an error. (An upsert may not filter with `$expr`, or this would be one step.)
+		*/
+		swap: async (key, expected, next, ttlSeconds) => {
+			const keysNow = await store();
+			const write = [{ $set: {
+				value: next,
+				expiresAt: ttlSeconds === void 0 ? null : expiryIn(ttlSeconds)
+			} }];
+			if (expected !== void 0) return (await keysNow.updateOne({
+				_id: key,
+				value: expected,
+				$expr: LIVE
+			}, write)).matchedCount === 1;
+			if ((await keysNow.updateOne({
+				_id: key,
+				$expr: { $not: [LIVE] }
+			}, write)).matchedCount === 1) return true;
+			try {
+				return (await keysNow.updateOne({
+					_id: key,
+					value: { $exists: false }
+				}, write, { upsert: true })).upsertedCount === 1;
+			} catch (error) {
+				if (error.code === DUPLICATE_KEY) return false;
+				throw error;
+			}
+		}
+	};
+};
+//#endregion
+export { createMongoKv };

package/dist/modules/mongo/stores.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/mysql/accounts.js

@@ -1,3 +1,4 @@
+import { activityDue } from "../../core/auth/sessionActivity.js";
 import { execute, selectOne, selectRows } from "./query.js";
 import { createSessionStore } from "./sessions.js";
 //#region src/modules/mysql/accounts.ts
@@ -50,12 +51,15 @@ var createAccountStore = (db, t) => {
 		* check — deactivating somebody has to end the session they are already holding, not just the next login.
 		*/
 		findAccountByToken: async (token) => {
-			const row = await selectOne(db, `SELECT ${ACCOUNT_COLUMNS}, s.expires_at AS session_expires_at
+			const row = await selectOne(db, `SELECT ${ACCOUNT_COLUMNS}, s.id AS session_id, s.expires_at AS session_expires_at,
+                s.last_active_at AS session_last_active_at
            FROM ${t.session} s
            JOIN ${t.account} a ON a.id = s.account_id
           WHERE s.token = ? AND a.status = 'active'
           LIMIT 1`, [token]);
 			if (!row) return;
+			const now = Math.floor(Date.now() / 1e3);
+			if (row.session_id !== void 0 && activityDue(row.session_last_active_at, now)) execute(db, `UPDATE ${t.session} SET last_active_at = ? WHERE id = ?`, [now, row.session_id]).catch(() => void 0);
 			const { roles, permissions } = await loadAccess(row.id);
 			return {
 				id: row.id,
@@ -120,15 +124,18 @@ var createAccountStore = (db, t) => {
 				]);
 				return;
 			}
-			await execute(db, `INSERT INTO ${t.session} (account_id, token, expires_at, refresh_token, refresh_expires_at, user_agent, ip)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+			await execute(db, `INSERT INTO ${t.session}
+           (account_id, token, expires_at, refresh_token, refresh_expires_at, user_agent, ip, app_name, app_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
 				userId,
 				session.token,
 				session.expiresAt,
 				session.refreshToken ?? null,
 				session.refreshExpiresAt ?? null,
 				context?.client?.userAgent?.slice(0, 255) ?? null,
-				context?.client?.ip ?? null
+				context?.client?.ip ?? null,
+				context?.client?.app?.name.slice(0, 120) ?? null,
+				context?.client?.app?.softwareId?.slice(0, 64) ?? null
 			]);
 		},
 		/**
@@ -335,22 +342,25 @@ var createAccountStore = (db, t) => {
 		* read whole and written whole, and a text column that a human can read in a crisis beats one they cannot.
 		*/
 		loadMfa: async (userId) => {
-			const row = await selectOne(db, `SELECT secret, confirmed_at, recovery_codes FROM ${t.mfa} WHERE account_id = ? LIMIT 1`, [userId]);
+			const row = await selectOne(db, `SELECT secret, confirmed_at, recovery_codes, last_used_step FROM ${t.mfa} WHERE account_id = ? LIMIT 1`, [userId]);
 			if (!row) return;
 			return {
 				secret: row.secret,
 				...row.confirmed_at !== null ? { confirmedAt: row.confirmed_at } : {},
-				recoveryCodes: (row.recovery_codes ?? "").split("\n").filter(Boolean)
+				recoveryCodes: (row.recovery_codes ?? "").split("\n").filter(Boolean),
+				...row.last_used_step !== null ? { lastUsedStep: row.last_used_step } : {}
 			};
 		},
 		saveMfa: async (userId, mfaRecord) => {
-			await execute(db, `INSERT INTO ${t.mfa} (account_id, secret, confirmed_at, recovery_codes) VALUES (?, ?, ?, ?)
+			await execute(db, `INSERT INTO ${t.mfa} (account_id, secret, confirmed_at, recovery_codes, last_used_step) VALUES (?, ?, ?, ?, ?)
          ON DUPLICATE KEY UPDATE
-           secret = VALUES(secret), confirmed_at = VALUES(confirmed_at), recovery_codes = VALUES(recovery_codes)`, [
+           secret = VALUES(secret), confirmed_at = VALUES(confirmed_at), recovery_codes = VALUES(recovery_codes),
+           last_used_step = VALUES(last_used_step)`, [
 				userId,
 				mfaRecord.secret,
 				mfaRecord.confirmedAt ?? null,
-				(mfaRecord.recoveryCodes ?? []).join("\n")
+				(mfaRecord.recoveryCodes ?? []).join("\n"),
+				mfaRecord.lastUsedStep ?? null
 			]);
 		},
 		deleteMfa: async (userId) => {

package/dist/modules/mysql/index.d.ts

@@ -63,5 +63,6 @@ export { TABLE_NAMES, tableNames } from './config';
 export { SCHEMA_VERSION } from './schema';
 export type { MysqlConfig, TableKey, Tables } from './config';
 export type { AccountSeed, MysqlAdmin, SpaceTokenSeed } from './admin';
-export type { SessionStore, SessionSummary } from './sessions';
+export type { SessionStore } from './sessions';
+export type { SessionSummary } from '../../core/auth/api';
 export type { IdentityStore, LinkedIdentity } from './identities';

package/dist/modules/mysql/jobs/index.d.ts

@@ -0,0 +1,5 @@
+export { createMysqlJobQueue } from './jobQueue';
+export { createMysqlKv } from './kv';
+export { mysqlJobSchemaStatements, mysqlJobSchemaUpgrades } from './schema';
+export type { MysqlJobQueue, MysqlJobQueueOptions } from './jobQueue';
+export type { MysqlKvOptions } from './kv';

package/dist/modules/mysql/jobs/jobQueue.d.ts

@@ -0,0 +1,40 @@
+import { ActionJobQueue } from '@plitzi/sdk-shared';
+import { Pool } from 'mysql2/promise';
+export type MysqlJobQueueOptions = {
+    /** A pool the deployment opened. The helper borrows connections from it and never ends it. */
+    pool: Pool;
+    /** Prefix for the three tables — `action_jobs`, `action_schedules`, `action_kv`. Default none. */
+    tablePrefix?: string;
+    /**
+     * Create the tables on first use (`CREATE TABLE IF NOT EXISTS`). Default true; false for a deployment that runs
+     * {@link mysqlJobSchemaStatements} through its own migrations.
+     */
+    createTables?: boolean;
+    /** How long a finished job stays readable. A waiting or running one never expires. Default 90 days. */
+    retentionDays?: number;
+};
+export type MysqlJobQueue = ActionJobQueue & {
+    /** Takes the store's clock again on the next call — after a failover to another primary. */
+    resyncClock: () => void;
+};
+/**
+ * An {@link ActionJobQueue} over tables in a MySQL database the deployment owns. Tested on MySQL 8; nothing in it
+ * needs more than 5.7.
+ *
+ * The helper for a deployment that already runs MySQL: it borrows connections from the pool it is handed, and creates
+ * its three tables on first use unless told not to. Every replica pointed at the same database shares the jobs and the
+ * schedules.
+ *
+ * ```ts
+ * import mysql from 'mysql2/promise';
+ * import { createMysqlJobQueue, createMysqlKv } from '@plitzi/sdk-server/mysql';
+ *
+ * const pool = mysql.createPool(process.env.DATABASE_URL);
+ * createServer({ action: { lookups, kv: createMysqlKv({ pool }), jobs: { queue: createMysqlJobQueue({ pool }) } } });
+ * ```
+ *
+ * The contract's rules, as MySQL keeps them: every instant is the SERVER's (`NOW(3)`), `enqueue` is idempotent by the
+ * primary key, `claim` takes each job with a single-row compare-and-set — so two workers never take the same one —
+ * and reaps a lapsed lease in the same write, and a schedule advances by compare-and-set too.
+ */
+export declare const createMysqlJobQueue: ({ pool, tablePrefix, createTables, retentionDays }: MysqlJobQueueOptions) => MysqlJobQueue;