nomkit 0.0.0

package/dist/queue/backends/pglite/notification-channel.js

@@ -0,0 +1,61 @@
+import { BaseNotificationChannel } from "agenda";
+//#region queue/backends/pglite/notification-channel.ts
+const CHANNEL = "agenda_jobs_channel";
+/**
+* Real-time notifications for the PGlite backend using NOTIFY/LISTEN.
+*/
+var PgliteNotificationChannel = class extends BaseNotificationChannel {
+	db;
+	unlisten = null;
+	constructor(db) {
+		super();
+		this.db = db;
+	}
+	async connect() {
+		if (this.state === "connected" || this.state === "connecting") return;
+		this.setState("connecting");
+		try {
+			this.unlisten = await this.db.listen(CHANNEL, (payload) => {
+				try {
+					const raw = JSON.parse(payload);
+					const notification = {
+						jobId: raw.jobId,
+						jobName: raw.jobName,
+						nextRunAt: raw.nextRunAt ? new Date(raw.nextRunAt) : null,
+						priority: raw.priority ?? 0,
+						timestamp: new Date(raw.timestamp ?? Date.now()),
+						source: raw.source
+					};
+					this.notifyHandlers(notification);
+				} catch (err) {
+					this.emit("error", err);
+				}
+			});
+			this.setState("connected");
+		} catch (err) {
+			this.setState("error");
+			this.emit("error", err);
+			throw err;
+		}
+	}
+	async disconnect() {
+		if (this.unlisten) {
+			await this.unlisten();
+			this.unlisten = null;
+		}
+		this.setState("disconnected");
+	}
+	async publish(notification) {
+		const payload = JSON.stringify({
+			jobId: notification.jobId,
+			jobName: notification.jobName,
+			nextRunAt: notification.nextRunAt,
+			priority: notification.priority,
+			timestamp: notification.timestamp,
+			source: notification.source
+		});
+		await this.db.query(`NOTIFY ${CHANNEL}, '${payload.replace(/'/g, "''")}'`);
+	}
+};
+//#endregion
+export { PgliteNotificationChannel };

package/dist/queue/backends/pglite/repository.d.ts

@@ -0,0 +1,38 @@
+import { JobId, JobParameters, JobRepository, JobRepositoryOptions, JobsOverview, JobsQueryOptions, JobsResult, RemoveJobsOptions } from "agenda";
+import { PGlite } from "@electric-sql/pglite";
+
+//#region queue/backends/pglite/repository.d.ts
+interface PgliteRepositoryOptions {
+  /** Table name to store jobs in.'.
+   * @default "agenda_jobs"
+   */
+  table?: string;
+}
+declare class PgliteRepository implements JobRepository {
+  private readonly db;
+  private readonly table;
+  private ready;
+  constructor(db: PGlite, options?: PgliteRepositoryOptions);
+  connect(): Promise<void>;
+  queryJobs(options?: JobsQueryOptions): Promise<JobsResult>;
+  getJobsOverview(): Promise<JobsOverview[]>;
+  getDistinctJobNames(): Promise<string[]>;
+  getJobById(id: string): Promise<JobParameters | null>;
+  getQueueSize(): Promise<number>;
+  private buildRemoveWhere;
+  removeJobs(options: RemoveJobsOptions): Promise<number>;
+  disableJobs(options: RemoveJobsOptions): Promise<number>;
+  enableJobs(options: RemoveJobsOptions): Promise<number>;
+  purgeAllJobs(): Promise<number>;
+  saveJob<DATA = unknown>(job: JobParameters<DATA>, _options?: JobRepositoryOptions): Promise<JobParameters<DATA>>;
+  saveJobState(job: JobParameters, _options?: JobRepositoryOptions): Promise<void>;
+  lockJob(job: JobParameters, _options?: JobRepositoryOptions): Promise<JobParameters | undefined>;
+  unlockJob(job: JobParameters): Promise<void>;
+  unlockJobs(jobIds: (JobId | string)[]): Promise<void>;
+  getNextJobToRun(jobName: string, nextScanAt: Date, lockDeadline: Date, now?: Date, _options?: JobRepositoryOptions): Promise<JobParameters | undefined>;
+  private insert;
+  private upsertById;
+  private upsertByMatch;
+}
+//#endregion
+export { PgliteRepository, PgliteRepositoryOptions };

package/dist/queue/backends/pglite/repository.js

@@ -0,0 +1,299 @@
+import { migratePGlite } from "./migrations/schema.js";
+import { computeJobState, toJobId } from "agenda";
+//#region queue/backends/pglite/repository.ts
+function toDate(v) {
+	return v == null ? void 0 : new Date(v);
+}
+function rowToJob(row) {
+	return {
+		_id: toJobId(row.id),
+		name: row.name,
+		type: row.type ?? "normal",
+		priority: row.priority,
+		nextRunAt: toDate(row.next_run_at) ?? null,
+		lastModifiedBy: row.last_modified_by ?? void 0,
+		lockedAt: toDate(row.locked_at),
+		lastFinishedAt: toDate(row.last_finished_at),
+		lastRunAt: toDate(row.last_run_at),
+		repeatInterval: row.repeat_interval ?? void 0,
+		repeatTimezone: row.repeat_timezone ?? void 0,
+		repeatAt: row.repeat_at ?? void 0,
+		data: row.data ?? {},
+		unique: row.is_unique ?? void 0,
+		uniqueOpts: row.unique_opts ?? void 0,
+		failReason: row.fail_reason ?? void 0,
+		failCount: row.fail_count,
+		failedAt: toDate(row.failed_at),
+		disabled: row.disabled,
+		progress: row.progress ?? void 0
+	};
+}
+function rowToJobWithState(row) {
+	const job = rowToJob(row);
+	return {
+		...job,
+		_id: job._id,
+		state: computeJobState(job)
+	};
+}
+const SORT_COLUMN_MAP = {
+	nextRunAt: "next_run_at",
+	lastRunAt: "last_run_at",
+	lastFinishedAt: "last_finished_at",
+	priority: "priority",
+	name: "name",
+	data: "data"
+};
+/**
+* Agenda's `unique` field uses dotted paths like 'data.userId' as keys.
+* Build a nested JSON object (rooted at `data`) suitable for a `data @> ...`
+* containment query, e.g. { 'data.userId': 5 } -> { userId: 5 }.
+*/
+function uniqueToDataContainment(unique) {
+	const root = {};
+	for (const [path, value] of Object.entries(unique)) {
+		const parts = (path.startsWith("data.") ? path.slice(5) : path).split(".");
+		let cursor = root;
+		for (let i = 0; i < parts.length - 1; i++) cursor = cursor[parts[i]] ??= {};
+		cursor[parts[parts.length - 1]] = value;
+	}
+	return root;
+}
+var PgliteRepository = class {
+	db;
+	table;
+	ready = null;
+	constructor(db, options = {}) {
+		this.db = db;
+		this.table = options.table ?? "agenda_jobs";
+	}
+	async connect() {
+		if (this.ready) return this.ready;
+		this.ready = (async () => {
+			await this.db.exec(migratePGlite(this.table));
+		})();
+		return this.ready;
+	}
+	async queryJobs(options = {}) {
+		const where = [];
+		const params = [];
+		const add = (clause, value) => {
+			params.push(value);
+			where.push(clause.replace("?", `$${params.length}`));
+		};
+		if (options.name) add("name = ?", options.name);
+		if (options.names?.length) add("name = ANY(?)", options.names);
+		if (options.id) add("id = ?", options.id);
+		if (options.ids?.length) add("id = ANY(?)", options.ids);
+		if (options.search) add("name ILIKE ?", `%${options.search}%`);
+		if (options.data !== void 0) add("data @> ?::jsonb", JSON.stringify(options.data));
+		if (options.includeDisabled === false) where.push("disabled = FALSE");
+		let sql = `SELECT * FROM "${this.table}"`;
+		if (where.length) sql += ` WHERE ${where.join(" AND ")}`;
+		const sortField = options.sort ? Object.keys(options.sort)[0] : void 0;
+		const sortDir = options.sort && Object.values(options.sort)[0] === -1 ? "DESC" : "ASC";
+		const column = sortField && SORT_COLUMN_MAP[sortField] || "next_run_at";
+		sql += ` ORDER BY ${column} ${sortDir} NULLS LAST`;
+		if (options.limit !== void 0) {
+			params.push(options.limit);
+			sql += ` LIMIT $${params.length}`;
+		}
+		if (options.skip !== void 0) {
+			params.push(options.skip);
+			sql += ` OFFSET $${params.length}`;
+		}
+		let jobs = (await this.db.query(sql, params)).rows.map(rowToJobWithState);
+		if (options.state) jobs = jobs.filter((j) => j.state === options.state);
+		const countResult = await this.db.query(`SELECT COUNT(*)::text AS count FROM "${this.table}"${where.length ? ` WHERE ${where.join(" AND ")}` : ""}`, params.slice(0, where.length));
+		return {
+			jobs,
+			total: Number(countResult.rows[0]?.count ?? jobs.length)
+		};
+	}
+	async getJobsOverview() {
+		return (await this.db.query(`
+      SELECT
+        name,
+        COUNT(*)::text AS total,
+        COUNT(*) FILTER (WHERE disabled = TRUE)::text AS paused,
+        COUNT(*) FILTER (WHERE locked_at IS NOT NULL AND last_finished_at IS NULL)::text AS running,
+        COUNT(*) FILTER (WHERE repeat_interval IS NOT NULL)::text AS repeating,
+        COUNT(*) FILTER (WHERE fail_count > 0 AND last_finished_at IS NOT NULL AND failed_at IS NOT NULL)::text AS failed,
+        COUNT(*) FILTER (WHERE next_run_at IS NULL AND last_finished_at IS NOT NULL AND fail_count = 0)::text AS completed,
+        COUNT(*) FILTER (WHERE next_run_at IS NOT NULL AND locked_at IS NULL AND disabled = FALSE)::text AS scheduled
+      FROM "${this.table}"
+      GROUP BY name
+      ORDER BY name
+    `)).rows.map((r) => ({
+			name: r.name,
+			total: Number(r.total),
+			running: Number(r.running),
+			scheduled: Number(r.scheduled),
+			queued: Number(r.scheduled),
+			completed: Number(r.completed),
+			failed: Number(r.failed),
+			repeating: Number(r.repeating),
+			paused: Number(r.paused)
+		}));
+	}
+	async getDistinctJobNames() {
+		return (await this.db.query(`SELECT DISTINCT name FROM "${this.table}" ORDER BY name`)).rows.map((r) => r.name);
+	}
+	async getJobById(id) {
+		const result = await this.db.query(`SELECT * FROM "${this.table}" WHERE id = $1`, [id]);
+		return result.rows[0] ? rowToJob(result.rows[0]) : null;
+	}
+	async getQueueSize() {
+		const result = await this.db.query(`SELECT COUNT(*)::text AS count FROM "${this.table}" WHERE next_run_at <= now() AND disabled = FALSE AND locked_at IS NULL`);
+		return Number(result.rows[0]?.count ?? 0);
+	}
+	buildRemoveWhere(options) {
+		const where = [];
+		const params = [];
+		const add = (clause, value) => {
+			params.push(value);
+			where.push(clause.replace("?", `$${params.length}`));
+		};
+		if (options.id) add("id = ?", String(options.id));
+		if (options.ids?.length) add("id = ANY(?)", options.ids.map(String));
+		if (options.name) add("name = ?", options.name);
+		if (options.names?.length) add("name = ANY(?)", options.names);
+		if (options.notNames?.length) add("NOT (name = ANY(?))", options.notNames);
+		if (options.data !== void 0) add("data @> ?::jsonb", JSON.stringify(options.data));
+		return {
+			clause: where.join(" AND "),
+			params
+		};
+	}
+	async removeJobs(options) {
+		const { clause, params } = this.buildRemoveWhere(options);
+		if (!clause) return 0;
+		return (await this.db.query(`DELETE FROM "${this.table}" WHERE ${clause}`, params)).affectedRows ?? 0;
+	}
+	async disableJobs(options) {
+		const { clause, params } = this.buildRemoveWhere(options);
+		if (!clause) return 0;
+		return (await this.db.query(`UPDATE "${this.table}" SET disabled = TRUE, updated_at = now() WHERE ${clause}`, params)).affectedRows ?? 0;
+	}
+	async enableJobs(options) {
+		const { clause, params } = this.buildRemoveWhere(options);
+		if (!clause) return 0;
+		return (await this.db.query(`UPDATE "${this.table}" SET disabled = FALSE, updated_at = now() WHERE ${clause}`, params)).affectedRows ?? 0;
+	}
+	async purgeAllJobs() {
+		return (await this.db.query(`DELETE FROM "${this.table}"`)).affectedRows ?? 0;
+	}
+	async saveJob(job, _options) {
+		const values = {
+			name: job.name,
+			type: job.type ?? "normal",
+			priority: job.priority ?? 0,
+			next_run_at: job.nextRunAt ?? null,
+			last_modified_by: job.lastModifiedBy ?? null,
+			locked_at: job.lockedAt ?? null,
+			last_finished_at: job.lastFinishedAt ?? null,
+			last_run_at: job.lastRunAt ?? null,
+			repeat_interval: job.repeatInterval != null ? String(job.repeatInterval) : null,
+			repeat_timezone: job.repeatTimezone ?? null,
+			repeat_at: job.repeatAt ?? null,
+			data: JSON.stringify(job.data ?? {}),
+			is_unique: job.unique != null ? JSON.stringify(job.unique) : null,
+			unique_opts: job.uniqueOpts != null ? JSON.stringify(job.uniqueOpts) : null,
+			fail_reason: job.failReason ?? null,
+			fail_count: job.failCount ?? 0,
+			failed_at: job.failedAt ?? null,
+			disabled: job.disabled ?? false,
+			progress: job.progress ?? null
+		};
+		if (job._id) return rowToJob(await this.upsertById(String(job._id), values));
+		if (job.type === "single") return rowToJob(await this.upsertByMatch("name = $1 AND type = $2", [job.name, "single"], values));
+		if (job.unique != null) {
+			const insertOnly = job.uniqueOpts?.insertOnly;
+			return rowToJob(await this.upsertByMatch("name = $1 AND data @> $2::jsonb", [job.name, JSON.stringify(uniqueToDataContainment(job.unique))], values, { insertOnly: !!insertOnly }));
+		}
+		return rowToJob(await this.insert(values));
+	}
+	async saveJobState(job, _options) {
+		if (!job._id) throw new Error("saveJobState requires job._id");
+		await this.db.query(`UPDATE "${this.table}" SET
+        locked_at = $1, last_finished_at = $2, last_run_at = $3, next_run_at = $4,
+        progress = $5, fail_reason = $6, fail_count = $7, failed_at = $8, updated_at = now()
+       WHERE id = $9`, [
+			job.lockedAt ?? null,
+			job.lastFinishedAt ?? null,
+			job.lastRunAt ?? null,
+			job.nextRunAt ?? null,
+			job.progress ?? null,
+			job.failReason ?? null,
+			job.failCount ?? 0,
+			job.failedAt ?? null,
+			String(job._id)
+		]);
+	}
+	async lockJob(job, _options) {
+		if (!job._id) return void 0;
+		const result = await this.db.query(`UPDATE "${this.table}"
+         SET locked_at = now(), updated_at = now()
+       WHERE id = $1 AND locked_at IS NULL
+       RETURNING *`, [String(job._id)]);
+		return result.rows[0] ? rowToJob(result.rows[0]) : void 0;
+	}
+	async unlockJob(job) {
+		if (!job._id) return;
+		await this.db.query(`UPDATE "${this.table}" SET locked_at = NULL, updated_at = now() WHERE id = $1`, [String(job._id)]);
+	}
+	async unlockJobs(jobIds) {
+		if (!jobIds.length) return;
+		await this.db.query(`UPDATE "${this.table}" SET locked_at = NULL, updated_at = now() WHERE id = ANY($1)`, [jobIds.map(String)]);
+	}
+	async getNextJobToRun(jobName, nextScanAt, lockDeadline, now = /* @__PURE__ */ new Date(), _options) {
+		const result = await this.db.query(`WITH candidate AS (
+         SELECT id FROM "${this.table}"
+         WHERE name = $1
+           AND disabled = FALSE
+           AND next_run_at <= $2
+           AND (locked_at IS NULL OR locked_at <= $3)
+         ORDER BY priority DESC, next_run_at ASC
+         FOR UPDATE SKIP LOCKED
+         LIMIT 1
+       )
+       UPDATE "${this.table}" t
+          SET locked_at = $4, updated_at = now()
+         FROM candidate
+        WHERE t.id = candidate.id
+        RETURNING t.*`, [
+			jobName,
+			nextScanAt,
+			lockDeadline,
+			now
+		]);
+		return result.rows[0] ? rowToJob(result.rows[0]) : void 0;
+	}
+	async insert(values) {
+		const cols = Object.keys(values);
+		const placeholders = cols.map((_, i) => `$${i + 1}`);
+		return (await this.db.query(`INSERT INTO "${this.table}" (${cols.join(", ")})
+       VALUES (${placeholders.join(", ")})
+       RETURNING *`, Object.values(values))).rows[0];
+	}
+	async upsertById(id, values) {
+		const setClause = Object.keys(values).map((c, i) => `${c} = $${i + 2}`).join(", ");
+		const result = await this.db.query(`UPDATE "${this.table}" SET ${setClause}, updated_at = now() WHERE id = $1 RETURNING *`, [id, ...Object.values(values)]);
+		if (result.rows[0]) return result.rows[0];
+		return this.insert({
+			id,
+			...values
+		});
+	}
+	async upsertByMatch(matchClause, matchParams, values, opts = {}) {
+		const existing = await this.db.query(`SELECT * FROM "${this.table}" WHERE ${matchClause} LIMIT 1`, matchParams);
+		if (existing.rows[0]) {
+			if (opts.insertOnly) return existing.rows[0];
+			const setClause = Object.keys(values).map((c, i) => `${c} = $${i + 2}`).join(", ");
+			return (await this.db.query(`UPDATE "${this.table}" SET ${setClause}, updated_at = now() WHERE id = $1 RETURNING *`, [existing.rows[0].id, ...Object.values(values)])).rows[0];
+		}
+		return this.insert(values);
+	}
+};
+//#endregion
+export { PgliteRepository };

package/dist/queue/backends/redis/index.d.ts

@@ -0,0 +1,7 @@
+export * from "@agendajs/redis-backend";
+
+//#region queue/backends/redis/index.d.ts
+
+import * as import__agendajs_redis_backend from "@agendajs/redis-backend";
+//#endregion
+export { import__agendajs_redis_backend as index_d_exports };

package/dist/queue/backends/redis/index.js

@@ -0,0 +1 @@
+export * from "@agendajs/redis-backend";

package/dist/queue/client/index.d.ts

@@ -0,0 +1,12 @@
+import { routes } from "../endpoints/routes.js";
+import { InferEndpoint } from "../../lib/utils.js";
+import { Endpoint } from "better-call";
+
+//#region queue/client/index.d.ts
+interface QueueClientOptions {
+  baseURL?: string;
+}
+declare function createQueueClient<TServer extends Record<string, any> = typeof routes>(options?: QueueClientOptions): InferRouteAPI<TServer>;
+type InferRouteAPI<T> = { [K in keyof T]: T[K] extends Endpoint<any, any, any, any, any, any, any, any> ? (request: InferEndpoint<T[K]>["request"]) => Promise<InferEndpoint<T[K]>["response"]> : T[K] extends Record<string, any> ? InferRouteAPI<T[K]> : never };
+//#endregion
+export { InferRouteAPI, QueueClientOptions, createQueueClient };

package/dist/queue/client/index.js

@@ -0,0 +1,31 @@
+import { createFetch } from "../../node_modules/.pnpm/@better-fetch_fetch@1.3.1/node_modules/@better-fetch/fetch/dist/index.js";
+//#region queue/client/index.ts
+function createQueueClient(options) {
+	const baseUrl = (options?.baseURL ?? "/queue").replace(/\/+$/, "");
+	let queueUrl;
+	if (baseUrl === "") queueUrl = "/queue";
+	else if (baseUrl.endsWith("/queue")) queueUrl = baseUrl;
+	else queueUrl = `${baseUrl}/queue`;
+	const supportsCredentials = typeof globalThis.Request !== "undefined" && "credentials" in Request.prototype;
+	const $fetch = createFetch({
+		baseURL: queueUrl,
+		throw: true,
+		...supportsCredentials ? { credentials: "include" } : {}
+	});
+	const createProxy = (path = []) => new Proxy(() => {}, {
+		get(_, prop) {
+			if (typeof prop !== "string") return;
+			if (prop === "then" || prop === "catch" || prop === "finally") return;
+			return createProxy([...path, prop]);
+		},
+		async apply(_, __, args) {
+			return $fetch("/" + path.map((segment) => segment.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)).join("/"), {
+				method: "POST",
+				body: args[0] ?? {}
+			});
+		}
+	});
+	return createProxy();
+}
+//#endregion
+export { createQueueClient };

package/dist/queue/endpoints/api.d.ts

@@ -0,0 +1,53 @@
+import z from "zod";
+
+//#region queue/endpoints/api.d.ts
+declare const CreateBillingSchema: z.ZodObject<{
+  id: z.ZodString;
+  customerId: z.ZodString;
+  productId: z.ZodString;
+  currentPeriodStart: z.ZodString;
+  currentPeriodEnd: z.ZodString;
+  interval: z.ZodString;
+  billingDetails: z.ZodObject<{
+    tokenKey: z.ZodString;
+  }, z.core.$strip>;
+  retryPolicy: z.ZodTuple<[z.ZodLiteral<"5s">, z.ZodLiteral<"6s">, z.ZodLiteral<"10s">], null>;
+  retryCount: z.ZodNumber;
+  skipImmediate: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, z.core.$strip>;
+type CreateBillingInfo = z.infer<typeof CreateBillingSchema>;
+declare const createJob: import("better-call").Endpoint<"/create-job", "POST", {
+  id: string;
+  customerId: string;
+  productId: string;
+  currentPeriodStart: string;
+  currentPeriodEnd: string;
+  interval: string;
+  billingDetails: {
+    tokenKey: string;
+  };
+  retryPolicy: ["5s", "6s", "10s"];
+  retryCount: number;
+  skipImmediate?: boolean | undefined;
+}, Record<string, any> | undefined, [], {
+  status: string;
+}, {
+  scope: "http";
+}, undefined>;
+declare const DeleteBillingSchema: z.ZodObject<{
+  id: z.ZodString;
+  customerId: z.ZodString;
+  productId: z.ZodString;
+}, z.core.$strip>;
+type DeleteBillingInfo = z.infer<typeof DeleteBillingSchema>;
+declare const deleteJob: import("better-call").Endpoint<"/delete-job", "POST", {
+  id: string;
+  customerId: string;
+  productId: string;
+}, Record<string, any> | undefined, [], {
+  status: string;
+}, {
+  scope: "http";
+}, undefined>;
+//#endregion
+export { CreateBillingInfo, DeleteBillingInfo, createJob, deleteJob };

package/dist/queue/endpoints/api.js

@@ -0,0 +1,45 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { defineQueueMethod } from "../lib/utils.js";
+import z from "zod";
+//#region queue/endpoints/api.ts
+var api_exports = /* @__PURE__ */ __exportAll({
+	createJob: () => createJob,
+	deleteJob: () => deleteJob
+});
+const createJob = defineQueueMethod({
+	input: z.object({
+		id: z.string("Subscription identifier is required").min(1).max(70),
+		customerId: z.string().min(1).max(70),
+		productId: z.string("Product identifier is required").min(1).max(70),
+		currentPeriodStart: z.string().min(1).max(40),
+		currentPeriodEnd: z.string().min(1).max(40),
+		interval: z.string({ error: "product interval is required" }).min(1).max(20),
+		billingDetails: z.object({ tokenKey: z.string() }),
+		retryPolicy: z.tuple([
+			z.literal("5s"),
+			z.literal("6s"),
+			z.literal("10s")
+		]),
+		retryCount: z.number(),
+		skipImmediate: z.boolean().default(false).optional()
+	}),
+	route: { path: "/create-job" }
+}, async (ctx) => {
+	const input = ctx.input;
+	await ctx.queue.billing.subscribe(input);
+	return { status: "queued" };
+});
+const deleteJob = defineQueueMethod({
+	input: z.object({
+		id: z.string(),
+		customerId: z.string().min(1).max(70),
+		productId: z.string("Product identifier is required").min(1).max(70)
+	}),
+	route: { path: "/delete-job" }
+}, async (ctx) => {
+	const input = ctx.input;
+	await ctx.queue.billing.unsubscribe(input);
+	return { status: "deleted" };
+});
+//#endregion
+export { api_exports, createJob, deleteJob };

package/dist/queue/endpoints/routes.d.ts

@@ -0,0 +1,32 @@
+//#region queue/endpoints/routes.d.ts
+declare const routes: {
+  readonly createJob: import("better-call").Endpoint<"/create-job", "POST", {
+    id: string;
+    customerId: string;
+    productId: string;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    interval: string;
+    billingDetails: {
+      tokenKey: string;
+    };
+    retryPolicy: ["5s", "6s", "10s"];
+    retryCount: number;
+    skipImmediate?: boolean | undefined;
+  }, Record<string, any> | undefined, [], {
+    status: string;
+  }, {
+    scope: "http";
+  }, undefined>;
+  readonly deleteJob: import("better-call").Endpoint<"/delete-job", "POST", {
+    id: string;
+    customerId: string;
+    productId: string;
+  }, Record<string, any> | undefined, [], {
+    status: string;
+  }, {
+    scope: "http";
+  }, undefined>;
+};
+//#endregion
+export { routes };

package/dist/queue/endpoints/routes.js

@@ -0,0 +1,5 @@
+import { api_exports } from "./api.js";
+//#region queue/endpoints/routes.ts
+const routes = { ...api_exports };
+//#endregion
+export { routes };

package/dist/queue/init.d.ts

@@ -0,0 +1,27 @@
+import { InferRouteAPI } from "./client/index.js";
+import { PGliteBackend } from "./backends/pglite/backend.js";
+import { index_d_exports } from "./backends/redis/index.js";
+import { Billing } from "./lib/billing.js";
+import { nomkitWebhooks } from "../endpoints/routes.js";
+import { Agenda } from "agenda";
+
+//#region queue/init.d.ts
+type Backends = PGliteBackend | index_d_exports.RedisBackend;
+interface QueueContext {
+  billing: Billing;
+  agenda: Agenda;
+  nomkit: InferRouteAPI<typeof nomkitWebhooks>;
+}
+interface CreateQueueOptions {
+  backend: Backends;
+  nomkitConfig: {
+    baseURL: string;
+  };
+}
+declare function createQueue(args: CreateQueueOptions): {
+  init(): Promise<void>;
+  terminate(): Promise<void>;
+  handler: (request: Request) => Promise<Response>;
+};
+//#endregion
+export { Backends, CreateQueueOptions, QueueContext, createQueue };

package/dist/queue/init.js

@@ -0,0 +1,31 @@
+import { routes } from "./endpoints/routes.js";
+import { Billing } from "./lib/billing.js";
+import { createNomKitClient } from "../client/index.js";
+import { createRouter } from "better-call";
+import { Agenda } from "agenda";
+//#region queue/init.ts
+function createQueue(args) {
+	if (!args) throw new Error("Missing required createQueue arguments");
+	if (!args?.nomkitConfig) throw new Error("Missing required nomkit arguments");
+	if (!args?.nomkitConfig?.baseURL) throw new Error("Missing required nomkit baseURL");
+	const agenda = new Agenda({ backend: args.backend });
+	const nomkitAPI = createNomKitClient({ baseURL: args.nomkitConfig.baseURL });
+	return {
+		async init() {
+			return agenda.start();
+		},
+		async terminate() {
+			return agenda.stop(true);
+		},
+		handler: createRouter(routes, { routerContext: {
+			agenda,
+			billing: new Billing({
+				agenda,
+				nomkit: nomkitAPI
+			}),
+			nomkit: nomkitAPI
+		} }).handler
+	};
+}
+//#endregion
+export { createQueue };

package/dist/queue/lib/billing.d.ts

@@ -0,0 +1,25 @@
+import { CreateBillingInfo, DeleteBillingInfo } from "../endpoints/api.js";
+import { QueueContext } from "../init.js";
+
+//#region queue/lib/billing.d.ts
+type Result<T, E = Error> = {
+  ok: true;
+  value: T;
+  error?: never;
+} | {
+  ok: false;
+  value?: never;
+  error: E;
+};
+declare class Billing {
+  private hasInit;
+  private agenda;
+  private nomkit;
+  private readonly ID;
+  private wf;
+  constructor(args: Omit<QueueContext, "billing">);
+  subscribe(args: CreateBillingInfo): Promise<void>;
+  unsubscribe(args: DeleteBillingInfo): Promise<void>;
+}
+//#endregion
+export { Billing, Result };