@shivaedev/jobs 0.34.0 → 0.35.0

package/src/server/internal/initializeJobs.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { PgBossInitialization } from "./PgBossInitialization.ts";
+
+export const initializeJobs = Effect.flatten(PgBossInitialization);

package/src/server/internal/operations/busy.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function busy(state: Pick<PgBossInspectionService, "busy">) {
+	return state.busy;
+}

package/src/server/internal/operations/changes.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function changes(state: Pick<PgBossInspectionService, "changes">) {
+	return state.changes;
+}

package/src/server/internal/operations/counts.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function counts(state: Pick<PgBossService, "counts">) {
+	return state.counts;
+}

package/src/server/internal/operations/deadLetteredJobs.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function deadLetteredJobs(state: Pick<PgBossService, "deadLetteredJobs">) {
+	return state.deadLetteredJobs;
+}

package/src/server/internal/operations/deferred.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function deferred(state: Pick<PgBossInspectionService, "deferred">) {
+	return state.deferred;
+}

package/src/server/internal/operations/deleteQueue.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function deleteQueue(state: Pick<PgBossService, "deleteQueue">) {
+	return state.deleteQueue;
+}

package/src/server/internal/operations/enqueue.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function enqueue(state: Pick<PgBossService, "enqueue">) {
+	return state.enqueue;
+}

package/src/server/internal/operations/failedJobs.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function failedJobs(state: Pick<PgBossService, "failedJobs">) {
+	return state.failedJobs;
+}

package/src/server/internal/operations/getJob.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function getJob(state: Pick<PgBossService, "getJob">) {
+	return state.getJob;
+}

package/src/server/internal/operations/health.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function health(state: Pick<PgBossService, "health">) {
+	return state.health;
+}

package/src/server/internal/operations/inspection.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function inspection(state: Pick<PgBossService, "inspection">) {
+	return state.inspection;
+}

package/src/server/internal/operations/inspectionHealth.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function inspectionHealth(state: Pick<PgBossInspectionService, "health">) {
+	return state.health;
+}

package/src/server/internal/operations/jobs.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function jobs(state: Pick<PgBossInspectionService, "jobs">) {
+	return state.jobs;
+}

package/src/server/internal/operations/queue.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function queue(state: Pick<PgBossInspectionService, "queue">) {
+	return state.queue;
+}

package/src/server/internal/operations/refreshQueueStats.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function refreshQueueStats(state: Pick<PgBossService, "refreshQueueStats">) {
+	return state.refreshQueueStats;
+}

package/src/server/internal/operations/retry.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function retry(state: Pick<PgBossService, "retry">) {
+	return state.retry;
+}

package/src/server/internal/operations/schedules.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function schedules(state: Pick<PgBossInspectionService, "schedules">) {
+	return state.schedules;
+}

package/src/server/internal/operations/schemaVersion.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function schemaVersion(state: Pick<PgBossInspectionService, "schemaVersion">) {
+	return state.schemaVersion;
+}

package/src/server/internal/operations/snapshot.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function snapshot(state: Pick<PgBossInspectionService, "snapshot">) {
+	return state.snapshot;
+}

package/src/server/internal/operations/storedJobs.ts

@@ -0,0 +1,5 @@
+import type { PgBossInspectionService } from "#server/inspection.ts";
+
+export function storedJobs(state: Pick<PgBossInspectionService, "storedJobs">) {
+	return state.storedJobs;
+}

package/src/server/internal/operations/unschedule.ts

@@ -0,0 +1,5 @@
+import type { PgBossService } from "#server/service.ts";
+
+export function unschedule(state: Pick<PgBossService, "unschedule">) {
+	return state.unschedule;
+}

package/src/server/internal/pgBossDefinitionLayer.ts

@@ -0,0 +1,65 @@
+import { type Context, Effect, Exit, Layer, Scope } from "effect";
+import { clientErrorReporter } from "#server/adapters/clientErrorReporter.ts";
+import { clientErrorSubscription } from "#server/adapters/clientErrorSubscription.ts";
+import { jobEngine } from "#server/adapters/jobEngine.ts";
+import type { JobRegistration, RegistrationRequirements } from "#server/definition.ts";
+import type { PgBossError, PgBossQueueNamesError, PgBossQueueOptionsError } from "#server/error.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+import type { PgBossLayerOptions, PgBossService } from "#server/service.ts";
+import { logClientError } from "./clientErrors.ts";
+import { JobEngine } from "./engine.ts";
+import { makeService } from "./makeService.ts";
+import { PgBossInitialization } from "./PgBossInitialization.ts";
+import { PgBossOperations } from "./PgBossOperations.ts";
+import { registrationName } from "./register.ts";
+import { registerReleasedJobs } from "./registerReleasedJobs.ts";
+import { validateQueueNames } from "./validateQueueNames.ts";
+
+export function pgBossDefinitionLayer<TIdentifier extends string, const TRegistrations extends readonly JobRegistration[], E>(
+	Service: Context.Service<TIdentifier, PgBossService>,
+	options: PgBossLayerOptions<TRegistrations, E>,
+	queueNames?: readonly string[],
+): Layer.Layer<
+	TIdentifier,
+	PgBossError | PgBossQueueNamesError | PgBossQueueOptionsError,
+	PgBoss | Exclude<RegistrationRequirements<TRegistrations>, TIdentifier> | E
+>;
+export function pgBossDefinitionLayer<TIdentifier extends string, R, E>(
+	Service: Context.Service<TIdentifier, PgBossService>,
+	options: PgBossLayerOptions<readonly JobRegistration<R>[], E>,
+	queueNames?: readonly string[],
+) {
+	return Layer.unwrap(
+		Effect.map(Effect.context<Exclude<R, TIdentifier> | E>(), (dependencies) =>
+			Layer.effect(Service, PgBossOperations).pipe(
+				Layer.provide(Layer.fresh(PgBossOperations.layer)),
+				Layer.provide(Layer.succeed(PgBossInitialization, initializePgBoss(Service, options, dependencies, queueNames))),
+			),
+		),
+	);
+}
+
+const initializePgBoss = Effect.fnUntraced(function* <TIdentifier extends string, R, E>(
+	Service: Context.Service<TIdentifier, PgBossService>,
+	options: PgBossLayerOptions<readonly JobRegistration<R>[], E>,
+	dependencies: Context.Context<Exclude<R, TIdentifier> | E>,
+	queueNames?: readonly string[],
+) {
+	yield* validateQueueNames(options.jobs, queueNames);
+	const acquired = yield* PgBoss;
+	const workerScope = yield* Scope.make();
+	const service = yield* makeService(acquired.client, options.jobs.map(registrationName), acquired.schema).pipe(
+		Effect.provideService(JobEngine, jobEngine(acquired.client, acquired.schema)),
+	);
+	yield* Effect.gen(function* () {
+		const context = yield* Effect.context<R | E>();
+		const reportError = options.onError ?? logClientError;
+		const report = yield* clientErrorReporter(reportError).pipe(Effect.provide(context));
+		const unsubscribe = yield* clientErrorSubscription(acquired.client, report);
+		yield* Effect.addFinalizer(() => Scope.close(workerScope, Exit.void).pipe(Effect.ensuring(Effect.sync(unsubscribe))));
+		yield* registerReleasedJobs(acquired.client, options.jobs, context, acquired.reused, acquired.schema, acquired.stop, options.retired).pipe(
+			Effect.provideService(Scope.Scope, workerScope),
+		);
+	}).pipe(Effect.provideService(Service, service), Effect.provide(dependencies));
+	return service;
+});

package/src/server/service.ts

@@ -1,8 +1,4 @@
-import { Context, Effect, Exit, Layer, type Option, type Redacted, type Schema, Scope } from "effect";
-import { defineService } from "@shivaedev/service/defineService.ts";
-import { genericMethod } from "@shivaedev/service/genericMethod.ts";
-import { clientErrorReporter } from "#server/adapters/clientErrorReporter.ts";
-import { jobEngine } from "#server/adapters/jobEngine.ts";
+import { Context, type Effect, Layer, type Option, type Redacted, type Schema } from "effect";
 import { clientEngine } from "#server/adapters/lifecycle.ts";
 import type { PgBossClientFactory } from "#server/client.ts";
 import type { ClientOptions, StopOptions } from "#server/clientOptions.ts";
@@ -19,13 +15,8 @@ import type {
 import type { DeadLetteredJob, JobPage, JobPageOptions, JobsHealth, ListedJob, QueueCounts } from "#server/health.ts";
 import type { PgBossInspectionService } from "#server/inspection.ts";
 import { acquireClient } from "#server/internal/acquireClient.ts";
-import { logClientError, subscribeClientErrors } from "#server/internal/clientErrors.ts";
-import { JobEngine } from "#server/internal/engine.ts";
 import { ClientEngine } from "#server/internal/lifecycle.ts";
-import { makeService } from "#server/internal/makeService.ts";
-import { registrationName } from "#server/internal/register.ts";
-import { registerReleasedJobs } from "#server/internal/registerReleasedJobs.ts";
-import { validateQueueNames } from "#server/internal/validateQueueNames.ts";
+import { pgBossDefinitionLayer } from "#server/internal/pgBossDefinitionLayer.ts";
 import type { Job } from "#server/job.ts";
 import { PgBoss } from "#server/PgBoss.ts";
 
@@ -65,10 +56,6 @@ export type PgBossOptions = Omit<ClientOptions, "connectionString"> & {
 	readonly stop?: StopOptions;
 };
 
-export function pgBossLayer(options: PgBossOptions): Layer.Layer<PgBoss, PgBossError | PgBossClientOptionsError> {
-	return Layer.effect(PgBoss, acquireClient(options)).pipe(Layer.provide(Layer.succeed(ClientEngine, clientEngine)));
-}
-
 export interface PgBossLayerOptions<TRegistrations extends readonly JobRegistration[], TErrorRequirements> {
 	readonly jobs: TRegistrations;
 	readonly onError?: (error: Error) => Effect.Effect<unknown, never, TErrorRequirements>;
@@ -85,58 +72,14 @@ export interface PgBossDefinition<TIdentifier extends string = string> extends C
 	>;
 }
 
+export function pgBossLayer(options: PgBossOptions): Layer.Layer<PgBoss, PgBossError | PgBossClientOptionsError> {
+	return Layer.effect(PgBoss, acquireClient(options)).pipe(Layer.provide(Layer.succeed(ClientEngine, clientEngine)));
+}
+
 export function makePgBoss<const TIdentifier extends string>(identifier: TIdentifier, queueNames?: readonly string[]): PgBossDefinition<TIdentifier> {
-	function definition<R, E>(
-		options: PgBossLayerOptions<readonly JobRegistration<R>[], E>,
-		dependencies: Context.Context<Exclude<R, TIdentifier> | E>,
-	) {
-		return defineService({
-			id: identifier,
-			initialize: Effect.gen(function* () {
-				yield* validateQueueNames(options.jobs, queueNames);
-				const acquired = yield* PgBoss;
-				const workerScope = yield* Scope.make();
-				const service = yield* makeService(acquired.client, options.jobs.map(registrationName), acquired.schema).pipe(
-					Effect.provideService(JobEngine, jobEngine(acquired.client, acquired.schema)),
-				);
-				yield* Effect.gen(function* () {
-					const context = yield* Effect.context<R | E>();
-					const reportError = options.onError ?? logClientError;
-					const report = yield* clientErrorReporter(reportError).pipe(Effect.provide(context));
-					const unsubscribe = subscribeClientErrors(acquired.client, report);
-					yield* Effect.addFinalizer(() => Scope.close(workerScope, Exit.void).pipe(Effect.ensuring(Effect.sync(unsubscribe))));
-					yield* registerReleasedJobs(acquired.client, options.jobs, context, acquired.reused, acquired.schema, acquired.stop, options.retired).pipe(
-						Effect.provideService(Scope.Scope, workerScope),
-					);
-				}).pipe(Effect.provideService(Service, service), Effect.provide(dependencies));
-				return service;
-			}),
-			methods: (service) => ({
-				counts: service.counts,
-				deadLetteredJobs: genericMethod(service.deadLetteredJobs),
-				deleteQueue: service.deleteQueue,
-				enqueue: genericMethod(service.enqueue),
-				failedJobs: genericMethod(service.failedJobs),
-				getJob: genericMethod(service.getJob),
-				health: service.health,
-				inspection: service.inspection,
-				refreshQueueStats: service.refreshQueueStats,
-				retry: service.retry,
-				unschedule: service.unschedule,
-			}),
-			requires: [PgBoss],
-		});
-	}
-	const Service: Context.Service<TIdentifier, PgBossService> = definition<never, never>({ jobs: [] }, Context.empty());
-	function layer<const TRegistrations extends readonly JobRegistration[], E = never>(
-		options: PgBossLayerOptions<TRegistrations, E>,
-	): Layer.Layer<
-		TIdentifier,
-		PgBossError | PgBossQueueNamesError | PgBossQueueOptionsError,
-		PgBoss | Exclude<RegistrationRequirements<TRegistrations>, TIdentifier> | E
-	>;
-	function layer<R = never, E = never>(options: PgBossLayerOptions<readonly JobRegistration<R>[], E>) {
-		return Layer.unwrap(Effect.map(Effect.context<Exclude<R, TIdentifier> | E>(), (dependencies) => definition(options, dependencies).layer));
+	const Service = Context.Service<TIdentifier, PgBossService>(identifier);
+	function layer<const TRegistrations extends readonly JobRegistration[], E = never>(options: PgBossLayerOptions<TRegistrations, E>) {
+		return pgBossDefinitionLayer(Service, options, queueNames);
 	}
 	return Object.assign(Service, { layer });
 }